Basically, programming language paradigms evolve and new languages are developed. Smalltalk was influential, but new languages have moved in and taken over the

Basically, programming language paradigms evolve and new languages are developed. Smalltalk was influential, but new languages have moved in and taken over the space where Smalltalk might have been used otherwise. I saw Smalltalk running on the Xerox Alto while in an advanced programming language group at Texas Instruments around 1978. Having some background in object oriented programming (from studying Simula-67 and working with MIT's CLU programming language) I was eager to read the excellent Smalltalk-80 books published a few years later. I actually got to use Smalltalk on my own PC when Digitalk came out with Smalltalk/V that ran on MS-DOS around 1986. I liked Smalltalk enough that I considered using it as the basis for a large commercial application I was designing in 1990, but ultimately I decided not to incorporate it in our system for a number of reasons. Smalltalk is talked about because its design and implementation are very elegant. However, it was designed around the idea of a single user environment supporting a custom GUI architecture. Source code wasn't stored and loaded from files, instead a system image was maintained and each time Smalltalk was started the current state was loaded and started running. The runtime, editor, debugger, even the GUI itself were a part of this image and subject to change as as application was being developed. It was a system seemingly designed for a computer with one programmer working on one program. This fluidity made working with the system fun and productive for a single programmer, but it wasn't obvious how it scaled up to larger multi-programmer projects. Furthermore, it was interpreted and that hurt back then when computers were much slower. Also, it's GUI graphics was designed around simple bitmapped black & white hardware, no grey scale or color. Again it wasn't obvious how this was supposed to work on different hardware. These limitations have a lot to do with the history and original limitations of the early systems that Smalltalk ran on, not the language; nevertheless, like other early interesting and seminal programming languages (APL for example) its best ideas were incorporated in future programming languages. The so-called "message-passing" paradigm of Smalltalk can be seen in Objective-C. It's implementation of classes as manipulatable objects themselves with their own meta-classes is seen in Ruby and Python and Common Lisp meta-programming. C and Pascal were contemporaries of Smalltalk and were both quite successful and influential. They had simpler, file based models for programs. Most systems used punched cards or simple CRT based terminals for construction of programs. This worked much better for C and Pascal than Smalltalk a language made for use with a GUI. Smalltalk was an early object oriented language, but it wasn't the first. Simula-67 was the first object oriented language and these ideas were further explored by MIT's CLU. At this time O-O ideas in programming were being explored, and this led to the evolutionary development of MODULA (from Pascal), C++ (from Simula67, Algol68, CLU), and Objective-C (from Smalltalk and C) and Ada (from many sources). At the time, I liked the simplicity of Objective-C, but C++ had the important backing of AT&T, was the most efficient implementation of object-oriented ideas, and came out the winner. C++ was complex being hampered by compatibility with C semantics; this gave Java an opening to become the other important Object Oriented language Other important developments in programming languages were taking place while this was happening. Lisp (the second oldest programming language in wide use) was splintering into numerous dialects. This was addressed by taking the union of the best ideas and Common Lisp came into being. A reaction to this large language was a small elegant Lisp called Scheme (perhaps the intersection of the best ideas in other Lisps). Object oriented ideas were incorporated in Common Lisp, but a new programming paradigm grew out of Lisp: functional programming exemplified by ML and its derivatives SML and OCaml, Haskell (influenced by Scheme), and their newer offspring: Rust, Swift, and Scala. These and many other further developments in programming languages, sadly, leave little room for a rebirth of Smalltalk.