Authors Deutsch and Goldberg look at the evolution of Smalltalk since its early coverage in BYTE. From
August 1991
:
Smalltalk: Yesterday, Today, and Tomorrow
A look back and a look ahead at this innovative
programming language-first featured 10 years ago in BYTE
by L. Peter Deutsch and Adele Goldberg
It's been a decade since the August 1981 issue of BYTE was published. That issue provided many people with a first comprehensive look at the then-fabled Smalltalk programming environment. In this article, we look back at how people thought about Smalltalk in those days. Then we'll look more broadly at how Smalltalk and object-oriented software technology has progressed since then; we'll also consider today's state of this technology and the market for it. Finally, we'll look ahead to objects in the year 2001, another decade hence.
1981: Sending Up the Balloon
In that BYTE issue of 10 years ago, we wanted to convey three ideas about Smalltalk and object-oriented software technology: first, that an interactive, incremental approach to software development can produce qualitative and quantitative improvements in productivity; second, that software should be desig
ned in units that are as autonomous as possible; and third, that developing software should be thought of in terms of building systems, rather than as black-box applications. The Smalltalk-8O system described in that issue so long ago was the exemplar of these three ideas.
Smalltalk was widely known then--and yet, largely unknown. Alan Kay and others from the Xerox Palo Alto Research Center (PARC) had been giving talks with tantalizing glimpses of the technology, but few people knew or understood its content. Thus, the cover of BYTE's Smalltalk issue--depicting a brightly colored Smalltalk hot-air balloon leaving an isolated island-symbolized our feeling that the time had arrived to start publicizing what we'd been doing. We believed we had new ideas that could make a real difference in how people developed software.
Many research examples developed at PARC demonstrated that object-oriented design could produce an appealing, intuitive, and direct mapping between objects in the real world and objects
in a software implementation. We saw this as a radical breakthrough in one of the most difficult and problem-prone steps in software development--identifying terms and relationships as understood by human participants of a particular situation with those understood by a computer.
We believed that this simple mapping of nouns to objects was all (or most) of the story about how to design with objects, and we presented it as such in the 1981 BYTE articles. Subsequently, in examples given in our books in 1983, we demonstrated that the power of objects applied to more than nouns: It also applied to events and processes. But this power was not as well explained or exploited.
The Smalltalk research project was founded on the belief that computer technologies are the key to improving communications channels between people, in business as well as personal settings. Our activities focused on finding new ways to organize information stored in a computer and to allow more direct access and manipulation of this
information.
The Smalltalk edition of BYTE introduced our approach to managing the complex information world of modern applications. It explained our methods for taking full advantage of new graphics and distributed computing and for improving the ability of experts in business and personal computing to describe their world models.
In retrospect, we are pleased that much of the software community has come to agree that the object-oriented approach to software organization is a new way to solve problems that is often better than the procedural approach. Although our ideas about problem-to-implementation mapping were incomplete--notably given the lack of formal methodologies--those ideas are widely accepted today.
1991: A Decade of Experience
What have we learned in the past decade based on the Smalltalk research and experience that was introduced to the public in those 1981 BYTE articles? The first idea, as we stated earlier, is simply that a highly interactive, highly incre
mental software development environment can produce a qualitative improvement in software development productivity. Even in 1981, Smalltalk systems were not the only ones with this characteristic--Lisp systems pioneered the approach in the early 1960s--but they were among the outstanding examples and were the ones that moved most successfully from proprietary hardware to the microprocessor mainstream. Today, the truth of this idea is widely recognized: The suppliers of environments for more-established languages like C, C + +, and Ada are now aiming to provide the benefits that Smalltalk introduced a decade ago.
The second idea is the basic idea of object-oriented software organization: that software should be designed in units that are as autonomous as possible, should correspond to identifiable entities in the problem domain whenever possible, and should communicate through identified interfaces. This idea grows out of work on modular software design that dates back, again, to the 1960s. Object-oriente
d terminology adds an emphasis on direct-mapping of concepts in the problem domain to software units, the idea of shared behavior and multiply instantiated state, and a focus on the interfaces between the units.
The last of these (the interfaces between the software units) makes it easy to think about systems that are configured or that grow dynamically. Smalltalk has no monopoly on new concepts, but it has been a leader in the public relations necessary to get these concepts out into the computing mainstream.
Object-oriented software organization has a natural relation to two current trends in software construction: combinable applications and open systems. Our interpretation of the term
open systems
is that for systems to grow, evolve, and combine gracefully, they should be constructed out of software with published interfaces. Functional software should be designed to be used as a component by other software, as opposed to being monolithically united with a particular interface designed
only for humans at a terminal.
The third important idea that has grown partly out of the Smalltalk work is related to the open-systems idea--namely, that one should always think about building software in the context of building systems, rather than in the context of black-box applications. In other words, one should examine explicitly the nature of both the downward interfaces (the resources or facilities the software uses) and the upward interfaces (the client's use of the software) and make them as undemanding as possible. Separating functionality from the user interface, which is the Smalltalk concept of model-presentation-interaction known as
model-view-controller
, is just one application of this principle--but a very important one.
The motivation behind much of the activity in the past decade was to move Smalltalk off its island and into easy availability for the general programming community. We look at this activity as being aimed at creating a credible, concrete, and robust realiza
tion of the ideas that we could present only in sheltered research form in 1981.
As Smalltalk has moved into the commercial world, it has encountered the familiar phenomenon of technological life span. A technology comes into existence on paper, often at a university. It then progresses to research papers, research prototypes, and usable research-scale artifacts. Finally, it goes into commercial use, first by the adventurous and then by the broad mass of users-getting adapted, extended, patched, and transported as long as it continues to solve problems well, and eventually getting replaced in many or all of its uses by newer technology. Smalltalk is now in this third stage--past the scrutiny of the adventurous and experiencing wider commercial adoption.
A Framework for the Future
One of the promising new concepts in object-oriented design--being actively explored today in Smalltalk as well as in other languages and environments-- is the concept of a framework. In an object-orien
ted environment that supports inheritance, reusable software that implements a single concept frequently takes the form of a specialization hierarchy in which the superclasses are more abstract (e.g., the Smalltalk classes
Collection
and
Number
), with certain operations deliberately left to implementation by more concrete subclasses (e.g.,
Array
as a concrete subclass of a kind of
Collection
, and
Integer
as a kind of
Number
). These holes in the superclasses (called
virtual functions
in C++ terminology) are an important part of the design.
A framework is a generalization of this idea to a group of classes working together. For example, the Smalltalk model-view-controller framework consists of three abstract superclasses that provide little more than definitions of how the concrete subclasses should work together, plus some bookkeeping code and default implementations of the most common operations. You reuse a framework by writing new concrete
subclasses and combining existing subclasses in new ways.
Another example of a framework involves the notion of a discrete event-driven simulation, in which objects interact to represent tasks, workers, locations (where tasks are carried out by the workers), and statistically based schedules for introducing tasks and workers. New components, specialized tasks, workers, and schedules can be described in order to reuse the general framework to create specific simulations. This concept is described fully in the book
Smalltalk-80: The Language
by Adele Goldberg and Dave Robson (Addison-Wesley, 1989).
The other Smalltalk idea receiving attention today is that building software is building systems. Software should have the same property as a fractal design: Assemblies built out of parts should have the same qualitative nature (such as definable inward and outward interfaces) as those parts. Developers must realize that they cannot predict all the ways that a piece of software will be used or all
the ways that it will be ported to use the facilities of new environments.
Smalltalk in the Marketplace
One of the powerful ideas that has attracted new attention as a result of the development of object-oriented software technology is the notion of reusable, combinable applications. Today, this idea is promoted at three levels: (1) operating systems, such as Unix pipes and
fork/exec
; (2) window systems, by way of interapplication communications conventions (e.g., Apple's Interapplication Communications, Microsoft's Dynamic Data Exchange, and the X Window System's Inter-Client Communications Conventions Manual); and (3) independent software architectures (including low-level ones such as Microsoft's dynamic link libraries and Sun Microsystems' shareable libraries, as well as high-level ones such as Patriot Partners' Constellation project and ParcPlace's object model and frameworks approach).
Many believe that the discipline of defined, published interfaces--which the obj
ect-oriented approach naturally promotes--will create a new marketplace for reusable software components. However, from our experience with many developers and users of Smalltalk systems in many environments, we think the key economic shift will be in a different area.
A public market is a loosely organized environment. Components placed in a market will face a wide variety of demands, and even well-designed components with minimally constrained interfaces will have trouble attracting a critical mass of customers.
On the other hand, within a single organization, reusable components can be developed and redesigned to span a large fraction of their intended uses. In this way, the accumulation of reusable code can become an important business asset and can be treated (appropriately) as an investment and a capital good, rather than simply as a cost (which is its present treatment).
In an object-oriented environment where inheritance is supported, it is not only individual components that are reused
. As we have noted, the design of interfaces between objects is often more important than the implementation of functions within objects. Frameworks can capture the structural design of software objects that address a given (partial) problem domain. As such, the frameworks developed and reused within an organization will, over time, come to capture and eventually even define the expertise of the organization--and, as such, can contribute to the organization's ability to meet its customers' needs. (This is sometimes called
competitive advantage
, but it applies equally well in situations where competition is not involved.)
2001: A Smalltalk Odyssey
If we look into our murky crystal ball, how do we see software's use of object technology in the next decade? How do we see it evolving?
We hope that in 2001, objects will be boring. In comparison, radical ideas of past decades--that system software should be written in higher-level languages or in languages with strong type sys
tems, and that computers can and should be seamlessly networked--are thoroughly accepted today. Whether to implement them is almost never an issue now, even though there is still plenty of discussion about how to implement them well.
In the same vein, we expect that 10 years from now, the object-oriented approach to software design and implementation will be an accepted, standard technique used in every language, library, database system, and operating system and will be taught in undergraduate computer science courses at every university. This is an issue of moving the technology further out into the world, and no major new thinking will be needed to accomplish it.
One significant technological advance will be that we will free ourselves even further from equating objects with the nouns in the problem domain. Some ofthe most remarkable advances in the usability of computer systems have come from recognizing that processes, as well as things, can and should be described, modeled, and manipulated. Th
erefore, we will see software objects being used to model time, places, actions, and events. We believe that this will lead to usability advances almost as dramatic as those resulting from the now-established window/icon/mouse/pull-down interfaces that were to a large extent inspired by the original Smalltalk work of the 1970s and 1980s.
photo_link (93 Kbytes)
L. Peter Deutsch is chief scientist and Adele Goldberg is president of ParcPlace Systems (Mountain View, CA).
5 Years Ago in BYTE
