Alan Kay has talked about improving Smalltalk and also suggested to "burn the disk packs" now and then to start fresh. Like he said, Dan Ingalls would rewrite the Smalltalk class library every few years. Here are some ideas off the top of my head for transcending Smalltalk (as a system and culture) to something better based largely on embracing other innovations that happened elsewhere. I acknowledge that some flavors of Smalltalk as well as other languages inspired by Smalltalk explore some of these already. And admittedly I have been away from the Smalltalk community for many years, so some of my concerns here may be somewhat dated -- even if they were concerns that originally drove me to look for alternatives or to experiment with building alternatives in Python/Jython, Java, JavaScript/TypeScript, and so on.
Smalltalk (or whatever it would be called) as a system and culture could more firmly embrace:
* The UNIX philosophy of working well with a filesystem with small utilities that use pipes and redirects to get work done. In some ways this is very close to what happens in a Smalltalk image of objects, except the filesystem provides an immediately persistent store and (unfortunately) a bunch of varying binary and textual formats for data. It is a common complaint that Smalltalk does not play nice with other tools. Smalltalk does not have to be that way since it can easily read files and do anything with them, but it is just a cultural thing perhaps? This would also include being able to easily run small stand-alone single-purpose apps like a Fahrenheit to Celsius temperature converter or other utility (which relates to later points on building simpler Smalltalk "image" files).
* "The power of plain text". Smalltalk could write out its image in plain text, but does not for whatever initial reason to be more compact. Smalltalkers created and improved image write code to rewrite binary images. But just cutting and pasting textual code is a lot easier than messing around with binary formats when defining Smalltalk âoeimagesâ. Ironically, the original Smalltalk's like Smalltalk-72 started with a readable plain text file to bootstrap themselves. (Craig Latta and others have explored building modern images from the ground up like with Spoon.) Smalltalk would benefit from being plain text first in every aspect, with binary formats for saving data used sparingly in special cases, given disk space is relatively cheap these days. JSON is a touchstone here, even if the ability to define complex literal constants was in VisualWorks using a notation that preceded JSON. Related is the idea of writing out JSON-like data but with a standard way to supply metadata like types.
* "If it does not have a URL it is broken" (my adage). The URL (Uniform Resource Locator) or really the broader URI (Uniform Resource Identifier) is a deep idea that uses the power of plain text to define a pointer. Typically, using the http scheme, that pointer names a computer on the internet and a path to a specific file for retrieval. But URIs can do more that that but in http and in a variety of other schemes liek, say, the magnet scheme for identifying resource via a hash of their content. URIs can also encapsulate the state of a small part of a system and used to return that part of the system to that state. While objects in a Smalltalk image can be found in various ways, why couldn't they all have consistent URLs or URIs? And why couldn't every operation or state in a Smalltalk browser (or other app) have a URI that can be used to return to it (perhaps also as part of an undo/redo system)? And what are other ways that Smalltalk could embrace the URI?
* Multiuser support. Related to the point on URLS, Smalltalk typically sees itself as a single-user system. With Squeak, we had a long debate over purpose, about whether Squeak was to support an individual or a community. As with the rise of Git and GitHub, we can see how important it is to support a community of coders. Smalltalkers have been moving in that direction (like with Montecello and Metacello and the Lively "parts bin"), but there still may be a cultural speed bump there which translated into less native support for that.
* Support for modules. It is hard for programmers to work together without some sort of module support with local namespaces. Sure programmers can prefix classes in an adhoc way with a couple of unique letters. But even such an adhoc workaround does not address people adding new methods to base classes. In JavaScript, adding new methods to base classes (other than as polyfills for a standard) is considered bad practice nowadays. Smalltalk derives a lot of power from a having a sea of objects in a common format that tool can work with. But there is some aspect of that which has not worked well and which can still be improved. Yes, there ar various suggestions and approaches for supporting modular code with Smalltalk, but it remains an issue.
* Image segments. A broader related idea is to be able to read and write parts of images. Some Smalltalks have supported image segmentation. Somehow it would be great to link that idea transparently with the ideas of modules, which would probably require tagging objects somehow with what segment (or perhaps application) they belonged to.
* Implementation inheritance is problematical. It's one thing for objects to delegate responsibility to other objects. But inheriting behavior form superclasses tends to lead to brittle code. A more powerful and modular paradigm might be to have classes which did not inherit code formally but defined all the behaviors they needed by drawing from methods or sets of methods that were defined elsewhere as well-crafted algorithms. The earliest Smalltalks were a bit more like this (without inheritance). See also the later point on functional programming support. Inheritance is one of those ideas that sounds great in theory (especially with overly simplistic examples) but creates immense problems in practice. Visual Basic has done really well by just having non-inheritable importable components that can be configured using an inspector.
* Parallel processing support. Smalltalk is inherently a parallel-processing language given the idea of message passing. But in practice the VMs people use tend to be single threaded (with perhaps cooperative threads within that model). Java, as an example, has a parallel processing model that makes it more scalable (see for example the book "Java Concurrency in Practice"). Occam is a language designed from the beginning in the 1980s to be for parallel processing on Transputers. Erlang is another great example to look at. Again there are Smalltalk systems that support parallelism like GemStone but they are not common. Python has also suffered from this issue with a "global interpreter lock". Yes, you can sort-of get around this by launching multiple VMs, but it is not the same and support within a language.
* A Free and Open Source license. This used to be an issue for decades among the mainstream Smalltalks. Even Squeak initially had a license that was problematical. I spent years trying to get people to see how the initial Squeak licenses was problematical for community development. I'm glad that was eventually resolved for Squeak. But Smalltalk has lost a lot of momentum over that. And VisualWorks -- arguably still the premier Smalltalk system -- is still under a proprietary license. Admittedly this is not that big of an issue anymore -- although I would still suggest having better tools to track licenses in code you import into a Smalltalk system.
* Reifying the VM. The base object in Smalltalk has a lot of behavior. I'd prefer it if the base Smalltalk object has no behavior and you used messaged like "VM print: object." to do basic things with it. Then you could explicitly add whatever behavior you wanted. Yes I know some Smalltalks support a more basic object -- again this is more a cultural thing reflected in libraries and programming practices.
* Better database support in the core. Like the above about files this is a sort-of cultural thing. Yes, Smalltalks can be great at accessing databases via various wrappers â" but with an object/table mismatch. I donâ(TM)t know what the answer is other than this remains a challenge. See also the point below on transactional and functional programming.
* Better native RDF / triple / semantic support and a tool-oriented paradigm for interacting with other systems. See my comments here for example:
"[fonc] On inventing the computing microscope/telescope for the dynamic semantic web"
https://fonc.vpri.narkive.com/...
* A "killer" application driving adoption like a better Thunderbird for handling email and all a person's social media (and then going beyond to add in ideas from the "Analyst" software). See for example my comments here:
https://pdfernhout.net/thunder...
https://mail.mozilla.org/piper...
* Functional programming (or multi-paradigm). I know that Smalltalk defined the message-passing "object-oriented" paradigm. But before Smalltalk there was Lisp, from which Smalltalk borrowed some ideas. Modern Lisps support functional programming using multiple dispatch for functions based on argument types. Functional programming is a great paradigm for a lot of a code base (even if conceptually writing 100% functional programming code tend to become problematical, especially with I/O). JavaScript and Python are multi-paradigm languages that support functional programming as well as class based programming (even if they don't support message passing, like with "doesNotUnderstand", which is part of the Smalltalk magic). SQL is also essentially a functional programming languages (if you squint at it). The notion of having a lump of typed data in memory or in a database on which you perform operations (often via transactions) is a powerful idea. Smalltalk can support that, but again this is a cultural thing.
* Undo and redo. As with the point above on transactions, MacApp (a programming framework fro Apple form the 1980s) and some other UI libraries supported creating actions which transformed the state of an application and were undoable. The Redux model in JavaScript for React is also in this direction somewhat (but not completely). Granted, Lively Kernel supports time-travel debugging to go back in time. But this is till not the same as UI library (or language) paradigms oriented around creating undoable and redoable transactions. This idea becomes even more important when support multi-user interactions on a shared virtual world.
* Reactive programming done like Mithril for JavaScript or as with the Elm language. Essentially, rather that the typical way of hooking up Smalltalk UIs using dependencies and observable data which sends "changed" messages (which can be hard to debug), complex UIs are easier to reason about if they work like some 3D video games and are re-rendered after they are "dirty" by being touched by user events (like mouse clicks). React itself also gets this wrong by prematurely optimizing an assumption that state should be stored and updates in each component. Stuff like RxJS is even worse, reinventing dependencies in strange way. It is a much easier to write and maintain UI code when you just write event handlers and the system knows that if such an even arrives, a redraw will eventually be needed. And if performance or other considerations are an issue, then you tweak things a bit or use Observables in a very sparing way.
* Being event driven instead of using polling. This is less of an issue the past decade with Squeak, but polling in early Smalltalks could burn a lot of CPU and make systems less responsive (higher latency) compared to being fully event driven. More recent Smalltalks are doing better here, but they may go too far (as with Morphic perhaps?) to make it hard to respond to basic events cleanly.
* Optional type declarations (like TypeScript for JavaScript) especially at a minimum for documentation or run-time assertions. Debatable if it creates excessive complexity for implementation.
* Better assembler support and perhaps even Forth support for self-hosted code generation, along with better tools for low-level interaction with hardware like a Commodore 64 machine language monitor.
* Minor changes to make the language a bit like more popular languages (like C or Java or Python), such as using double quotes for strings (instead of comments), using double slashes for line comments, using slash star for multi-line comments, and using multi-quotes for longer multi-line strings with embedded quotes like with Python triple quotes. Personally I feel the apostrophe should be generally reserved for its use in text instead of defining a string. Such changes are not especially essential though, but they would ease the learning curve a bit for people who are already used to other languages.
* Support for both text-based and visual programming. Fabrik and Morphic are interesting visual programming ideas and make for impressive demos for simpler systems (like Dan Ingall's "windmill" example with a rotating stars and a rectangle and another star). Stormworks and Minecraft and more games and applications also support visual programming. But using visual programming can involve a lot of mouse clicking and the results can be problematical to view and search and change as plain text (see for example VisualAge Smalltalk). There obviously is a power to visual programming and hooking up components that way. But more thought need to go into making visual programming transparently inter-operable with plain text programming. And yes, I know there are some experiments in these directions already, but again maybe it is a cultural thing? But if I could only have one paradigm, I would still prefer the plain text approach to hook stuff up (especially coupled with Mithril-like reactive programming for UIs as above).
* A great set of common UI widgets that work in expected ways and are well-documented and reasonably stable.
* An emphasis more on *standards* than *implementations*. Standards need FOSS reference implementations, but the two are different. When I was at IBM Research circa 2000, a mantra there was cooperate with other companies on standards but compete on implementations. By emphasizing good standards for storing, transmitting, inspecting, and transforming all types of objects, the Smalltalk community could make it easier to collaborate over the long haul. Of course, FOSS developers don't have to compete on implementations either, but it is true that as developers may have different implementation approaches they want to experiment with and advocate for. But the key question is what standards can Smalltalk developers agree on? Including on what ways to make standards extensible with semantic versioning or whatever so they can continue to be adapted to future needs while still preserving the best of the past?
Things Smalltalk should keep:
* the distinction between named code (from a class) and named data in an object (something both JavaScript and Python lack and suffer for as they in practice mix code and data in each object).
* message passing and "doesNotUnderstand"
* being written in itself
* great inspectors
* great debugger which you can write code in
* keyword syntax to label arguments
* tunable garbage collection
* the ability to generate code in other languages like C
* being able to be put on bare metal
* running in a browser like with SqueakJS or Lively Kernel
* the shared effort for supporting a great cross-platform VM
That said, I have followed Dan Ingalls' lead to work in JavaScript/TypeScript for the ubiquitous nature of it. If the original Smalltalk team had to choose between JavaScript everything on systems with over 1000X more speed and memory than what they worked with in 1972 or using Smalltalk, they probably would pick the modern option.
But can we do better? As with some criticisms on Quora by Pharo developers of Dan Ingall's Lively Kernel work, what if we had put the same effort into making a Smalltalk better?
Web technologies also have lots of issues. It took quite a while yesterday and like a zillion downloaded components (well, hundreds, via npm) to get Lively Kernel installed locally (including of both Babel and Google's Closure library). The disk footprint in the lively.kernel directory is about 1,659,240,000 bytes (without having written any substantial code in it). Meanwhile Cuis Smalltalk -- as an example -- strives for clarity and purity and small footprint. And Pharo can be installed much more easily. Both are less than one tenth the size of lively kernel install. Likely Kernel is an impressive work of art and ingenuity. Maybe disk space does not matter much now -- but complexity still does, and building on JavaScript and web technologies introduces a lot of complexity. Is it worth it? Good question.
Anyway, about all the time I have to refine this list right now.