Smalltalk Environment Research Articles

On the integration of Smalltalk and Java

After decades of development in programming languages and programming environments, Smalltalk is still one of few environments that provide advanced features and is used in the industry. However, as Java became prevalent, the ability to call a Java code from Smalltalk became important. A traditional approach to integrate the Java and Smalltalk languages is through low-level communication between separate Java and Smalltalk virtual machines. To our best knowledge there is no other project attempting to execute and integrate the Java language directly in the Smalltalk environment. A direct integration allows for a very tight integration of the languages and their objects within a single environment. Yet integration and language interoperability impose challenging issues related to method naming conventions, method overloading, exception handling and thread-locking mechanisms.In this paper we describe ways to overcome these challenges and to integrate Java into the Smalltalk environment. We focus on a possibility to call a Java code from Smalltalk using standard Smalltalk idioms while the semantics of both languages remains preserved. We present stx:libjava – an implementation of a Java virtual machine within Smalltalk/X – as a validation of our approach.

Creating sophisticated development tools with OmniBrowser

Smalltalk is not only an object-oriented programming language; it is also known for its extensive integrated development environment supporting interactive and dynamic programming. While the default tools are adequate for browsing the code and developing applications, it is often cumbersome to extend the environment to support new language constructs or to build additional tools supporting new ways of navigating and presenting source code. In this paper, we present the OmniBrowser, a browser framework that supports the definition of browsers based on an explicit metamodel. With OmniBrowser a domain model is described in a graph and the navigation in this graph is specified in its associated metagraph. We present how new browsers are built from predefined parts and how new tools are easily described. The browser framework is implemented in the Squeak Smalltalk environment. This paper shows several concrete instantiations of the framework: a remake of the ubiquitous Smalltalk system browser, a coverage browser, the Duo Browser and the dynamic protocols browser.

Uniform and safe metaclass composition

In pure object-oriented languages, classes are objects, instances of other classes called metaclasses. In the same way as classes define the properties of their instances, metaclasses define the properties of classes. It is therefore very natural to wish to reuse class properties, utilizing them amongst several classes. However this introduced metaclass composition problems, i.e., code fragments applied to one class may break when used on another class due to the inheritance relationship between their respective metaclasses. Numerous approaches have tried to solve metaclass composition problems, but they always resort to an ad-hoc manner of handling conflicting properties, alienating the meta-programmer. We propose a uniform approach that represents class properties as traits, groups of methods that act as a unit of reuse from which classes are composed. Like all the other classes in the system, metaclasses are composed out of traits. This solution supports the reuse of class properties, and their safe and automatic composition based on explicit conflict resolution. The paper discusses traits and our solution, shows concrete examples implemented in the Smalltalk environment Squeak, and compares our approach with existing models for composing class properties.

Classboxes: controlling visibility of class extensions

A class extension is a method that is defined in a module, but whose class is defined elsewhere. Class extensions offer a convenient way to incrementally modify existing classes when subclassing is inappropriate. Unfortunately existing approaches suffer from various limitations. Either class extensions have a global impact, with possibly negative effects for unexpected clients, or they have a purely local impact, with negative results for collaborating clients. Furthermore, conflicting class extensions are either disallowed, or resolved by linearization, with consequent negative effects. To solve these problems we present classboxes, a module system for object-oriented languages that provides for method addition and replacement. Moreover, the changes made by a classbox are only visible to that classbox (or classboxes that import it), a feature we call local rebinding. To validate the model we have implemented it in the Squeak Smalltalk environment, and performed benchmarks.

Object-oriented finite elements II. A symbolic environment for automatic programming

The object-oriented approach is getting more and more attention in the Finite Element community. The object-oriented approach leads to faster prototyping of new codes and better reusability. In this context, the authors' research group has systematically developed a methodology of coding finite elements [1–4]. In a companion paper [5], the key features of an interactive quasi-automatic environment for the development of a new numerical Finite Element model for the solution of an initial-boundary-value problem have been presented. In this article, the detailed description of the proposed environment which is integrated in a Smalltalk environment is described.

Smalltalk training

Smalltalk was originally intended to make the computer more accessible. However, although the language itself is simple, it is becoming common knowledge that becoming truly proficient with the Smalltalk environment is no simple achievement. Although we are still far short of being able to inject all the wisdom of a seasoned Smalltalk guru into a guru-wanna-be in a few short weeks, the industry has become more efficient in spreading the knowledge, while its education processes have matured. The effectiveness of the training available today for objects and Smalltalk exceeds that of many of the other technologies with which we are becoming inundated. This is especially true when one realizes the significant difference between Smalltalk and other technologies and the relatively wide gulf between the known and the unknown.

An intelligent tutoring system for the Dijkstra-Gries methodology

The paper describes the design and implementation of an intelligent tutoring system for the Dijkstra-Gries programming methodology as defined by Gries (1981) in "The Science of Programming". The first part of the paper identifies the requirements of intelligent tutoring systems in general and those of the methodology in particular. It shows the suitability of the Smalltalk environment for developing expandable intelligent systems and the compatibility of Smalltalk's object-oriented paradigm with the Gries methodology's goal/plan approach to programming. We then describe how these requirements are met: an overview of the system's support of the methodology and the modules that enable the system to respond intelligently. As an example, a reusable tutorial part is presented, first from a student's perspective, then from an author's perspective. Finally the results of an evaluation of the system drawn from actual student experience are presented.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Multiple multimodal mentors: delivering computer-based instruction via specialized anthropomorphic advisors

Abstract We describe the Smalltalk Gurus, components of the MoleHill intelligent tutoring system for Smalltalk programming. The Gurus offer help on plans for achieving goals in the Smalltalk environment, as well as remediation for students' incorrect and less-than-optimal plans. The Gurus' assistance is provided via the multimodal media of animation and voice-over audio. MoleHill employs multiple Gurus to deliver advice and instruction concerning disparate information domains, thus facilitating learners' cognitive organization and assimilation of new knowledge and information. We have labelled the approach instantiated by the Smalltalk Gurus the guru instructional model, one which is generally applicable to computer-based advisory systems.

SPiCE: a system for translating Smalltalk programs into a C environment

Smalltalk-80 (hereafter referred to as Smalltalk), which is one of the most productive programming languages/environments, is very well suited for prototyping of applications but it is less well suited for delivering applications because applications can neither run in isolation from the Smalltalk environment nor be combined with other programs written in other languages. One way to make Smalltalk suitable for delivering applications is to translate Smalltalk into a compiler language such as C. By translating Smalltalk code into portable and interoperable C code, it is possible to deliver a stand-alone version of Smalltalk applications, and to develop an application partly in Smalltalk and partly in C. However, there are some difficulties in translating Smalltalk code into such a C code. First, the execution model of Smalltalk, which creates activation records as objects, is very different from that of C, and second, Smalltalk and C have very different approaches to storage management. We have implemented SPiCE, a system for translating Smalltalk into C. Our approach to the translation is to create runtime replacement classes implementing the same functionality of Smalltalk classes that are inherently part of the Smalltalk execution model, and to provide semi-conservative real-time compacting garbage collection that works without language support. >

Information system design for optical fibre manufacturing using an object-oriented approach

Abstract This paper describes an object-oriented approach to designing an information system which supports the engineering and production information needs of optical fibre manufacturing*. The resulting prototype information system was developed at the Material Handling Research Center in the USA. This object-oriented approach follows these steps: understanding the layout of the optical fibre manufacturing processes, defining the information system requirements, developing object-oriented models, and implementing a prototype information system in the Smalltalk environment. In order to evaluate this object-oriented approach, this paper describes and compares similarities and differences with an earlier relational approach. The results indicate that the object-oriented approach provides a superset of the functionality contained in the relational approach. Specifically, beyond the inclusion of manufacturing data, the object-oriented approach captures the operations that are performed on the data.

Maintenance support for object-oriented programs

This paper describes some of the difficulties that may be expected in the maintenance of software developed using the new object oriented languages. The concepts of inheritance and of polymorphism provide the great strengths of these languages, but they also introduce difficulties in program analysis and understanding. The paper analyzes problems of dynamic binding, object dependencies, dispersed program structure, control of polymorphism, high-level understanding, and detailed code understanding. Examples are presented based on code from a PC Smalltalk environment and from studies of two systems under development at Bell Communications Research

Writing efficient Smalltalk programs (abstract)

Smalltalk has a reputation for being slow and a offers many ways to create inefficient code, and memory hog. In reality, the Smalltalk environment programmers often exploit those opportunities. However, there are just as many ways to create efficient code, some of which may not be available in more traditional languages. Whether an application is efficient or not has more to do with the way the programmer has used the available tools than the tools themselves. This tutorial teaches Smalltalk programmers how to write efficient programs. The emphasis is on how to exploit, rather than sacrifice, the benefits of good object-oriented design. You should have at least six months experience with Smalltalk writing non-toy programs to get the most benefit from the tutorial.

An accidental translator from Smalltalk to ANSI C

Smalltalk's great advantage over all of its competitors is the sophistication of its environment and the elegance of its implementation of the Object-Oriented paradigm. One of its disadvantages is that Smalltalk applications cannot be separated from the Smalltalk environment. The completeness of the environment as opposed to its insularity, appear to represent a natural trade-off. This paper describes an initially limited attempt to resolve the trade-off, for the purposes of a particular application, which subsequently grew in scope.

An object oriented design and simulation system for VLSI

This paper introduces an Interactive Design and Simulation System for VLSI integrated circuits ( ‘IDaSS’). IDaSS has a ‘language’ level between RTL and higher level languages. It uses graphics/text based editing and simulation tools, achieving high designer productivity by integrating designing, simulation and debugging into a seamless package. IDaSS is built in the Smalltalk environment, and inherits the interactive multi-window menu-driven way of operation from Smalltalk.

ASCETA: AN EXPERT SYSTEM FOR PASSIVE NETWORK SYNTHESIS

An expert system for passive network synthesis and filter design, developed in an object-oriented environment, is presented. It has been implemented using a shell written in the language SMALL2ALK/V and is highly interactive. It has been conceived and developed mainly for educational purposes, and its implementation has demonstrated the suitability of the object-oriented approach and of the SMALLTALK environment for this kind of problem.

Introducing object-oriented programming into the computer science curriculum

In recent years, object-oriented programming languages and object-oriented program design have become increasingly popular. Dialects of many popular programming languages are now available which support the major concepts of object-oriented programming; namely message-passing, classes, generic operations and inheritance. Experience in the paradigm is increasingly supporting the view that object-oriented programming may be to the 80's what structured programming was to the 70's in terms of its influence on software development. After reviewing the notions of object-oriented programming, we describe our experiences in introducing the object-oriented paradigm into the Computer Science curriculum. The impact was felt in four courses dealing with data types and data structures, programming languages, software engineering, and compiler construction. In addition, we describe the use of the Smalltalk environment in advanced course and project work. We chronicle our experiences in the expectation that they will be of benefit to other educators considering adopting the object-oriented paradigm. Finally, we review the potential benefits of introducing object-oriented programming into the computer science curriculum.