The browser inspector stuff looks very interesting, gotta check this out!

Very cool!

Just saw your post to the Common Lisp reddit.

Consider also posting to the larger Lisp reddit.

this is great! i was on a common lisp exploration a few months ago and mostly got stuck wishing i had smalltalk style tooling

Yes, Whisker is exactly what came to mind for me as well.

I don't currently use Smalltalk, most of my code is now written (and read) in vscode. The means available for showing the context around the code under consideration (splitting and resizing panes, hunting through lists of tabs, scrolling around) feel pretty crude by comparison.

Eclipse, due to its evolution from Visual Age set of IDEs, coded in Smalltalk, also keeps a code browser view for Java that is like the Smalltalk one.

I worked as a Smalltalk developer for a few years, and it spoiled to such an extent that I’ve tried to make an extension for IntelliJ to replicate the browser for Java development. Maybe I should revive that project, actually…

Rather than a fixed 4-pane browser, a potential solution is to use something like the macOS finder's "Column" view, where each layer of the hierarchy produces a new pane, as many as you need to drill down to the particular thing you're looking for.

Whenever I tried dabbling in Smalltalk, I would feel constrained by the system in terms of raw real estate. I never cared to view the system through the narrow slit of the method code editor. I would suffer the explosion of windows. All of it was off putting to me, and I never pushed through it to work with a project long enough in order for it to be comfortable.

But, let's contrast it to Java, which pretty much is in the same boat as a modern Smalltalk. A very large core system of packages, classes, and methods. Wrapped in a spider web of dependencies. And, granted, I've been working with Java a long time, and this is all quite comfortable to me. But at the same time, it doesn't suffer the issues that the Smalltalk browser presents.

Consider, regarding the parent point, the entirety of the JDK is not typically presented in the modern IDE. It's just back there. There's no real estate committed to it. There's your project (typically), with its classes.

I use NetBeans, so I have a project view of packages and classes, I have code tabs of individual classes, and a contextual method navigator within a class.

Its routine to potentially have a tab explosion, in contrast to a window explosion when exploring code. But when I do that, all I get is the code window, not the entire project or context of the class.

That is, in my code, I can click on, say, an ArrayList method, and jump to the JDK source code for the method within the ArrayList. I don't get its entire package hierarchy, I get its method list (uncatagorized, but alphabetical) while viewing the code file. So, the impact of viewing a new method is minimal -- it's just a new tab.

But as a benefit, I get to see not only the method I'm interested in, but I get to see the context of the code around the method. When I code, I don't write methods in a vacuum. I organize my code somewhat around aspect of the logic of the class. So, if there's a method that does one thing, chances are that the methods around it are doing similar or related things, or part of the logic of whats going on. Proximity in the source file tells part of the story not captured at the method level.

Sure, I can click around, in the navigator, in the IDE directly to visit other methods, but I can also scroll about, have the breadth of the class as a canvas and gather the ebb and flow of the logic within it. This is stark contrast to the ST "tiny" method browser.

I can also search globally within the source methods rather than just method signatures, while still having access to call trees and references and many of the other wonders of the ST browser.

Extending that, an outliner can be a great way to deal with this stuff. The problem becomes the self-referential nature of OO systems. Outliners are good when you get to the method of interest, but then you have the problem of browsing senders and implementers.

Still, there's nothing worse than a Smalltalk without a class category list. Smalltalk/MT, for example, just had a class hierarchy browser, and the category class member variable was left blank. I found it very hard to know where to start looking for behavior.

While I agree that the package column has room for improvement, some of the 'largesse' can be handled by the search field at the bottom of it, and once you get to doing something serious you could set up your own image and ditch a lot or most of the standard distribution.

I think I'd prefer a pane view over a tree view because the higher levels retain their scroll position even as I browse beneath. Is there a similar UX possible for tree views?

Longtime HN user morphle, who commented elsewhere in this thread, has researched and designed chips and hardware for that purpose (edit: for scaling that form of computing). He has been trying to find funds and partners to bring them to market.

Disclaimer: never met or spoken or worked with him

Who remembers the Occam folding editor (1983)? This was the first time I saw this kind of outline-based navigation for code: https://www.transputer.net/tn/03/tn03.html#x1-30002

Also it'd be nice to have something that is more spatial. A famous memory technique is remembering where things are in space[1], but I've never seen a code browser that works spatially. (I have no idea how to actually do this.)

[1] https://en.wikipedia.org/wiki/Method_of_loci

I couldn’t discern a point either. Having been a smalltalk programmer the only thing I really miss is the exceptions and the way they could be intercepted and a value injected back into the execution flow.

I’m sure we could code up a class browser for any language that offers introspection like C# but I don’t see the point any more when programming has reverted to functional styles or chunks of lambda expressions.

Historically, Smalltalk has many browsers (views). This System Browser is one of many browsers, and the most busy-looking.

You can browse within it, and also spawn off other kinds of browsers from it.

And these browsers are extensible with others. As someone new to Smalltalk, I was pretty easily able to add a visual class hierarchy browser into this environment:

https://www.neilvandyke.org/smalltalk-chg/

Half the things we know or think about in HCI, the people at PARC figured out before we were born, and sometimes before the hardware to test it existed.

https://worrydream.com/EarlyHistoryOfSmalltalk/

They have many views, the trouble is the proliferation of these views as you go through the code. You browse to a class and method, then you want to see the senders, and so you open that, and then see the implementors of a method a sender calls, and so on.

https://blog.lorenzano.eu/content/images/2026/01/Pasted-imag...

smalltalk invented the concept of views

Yeah there's a difference between being popular and influential. Smalltalk is influential without being all that popular.

I suspect that's largely because most smalltalk implementations don't store code in git. "A smalltalk" is more like a Linux distro than a phone app. It's almost like the main purpose of a smalltalk is to build more smalltalks. It's a good way for developers to build a deep, powerful tool for other developers, but it's a less good way to build user experiences targeted at non-programmers, who are going to want to have a bunch of different apps to use not a bunch of different operating systems to use.

Good economics for the classroom; bad economics for the real world. Then and now, though, a great way to play with novel ideas in programming languages.

The Potsdam university (near Berlin, Germany) and Hasno Platner Instute [1] has been actively teaching and researching Squeak Smalltalk for decades. Same in Buenos Aires and several other places. Science papers every month for 5 decades, under many names besides Smalltalk. Weekly online conferences, presentations.

https://www.hpi.uni-potsdam.de/hirschfeld/projects/index.htm...

People like the language - I like it though I have only written a few bits and bobs in it. They also like Fortran, Prolog, and (dare I say it) Haskell, and many others that don't appear here so often. Just because a language is not this week's hotness (looking at you Rust) does not make it "obsolete".

Likely because whilst it didn't work out commercially, the ideas smalltalk, prolog and other more esoteric languages (forth, apl) focus on are themselves very interesting.

A lot of systems are obsolete, in the sense that you cannot find work in them. Nonetheless, people use them to prototype ideas that will eventually find their way into industry. Is Haskell obsolete? Not exactly, but it's hard to find real-world projects that use it. Concepts developed in Haskell get imported into other systems.

Systems are only truly obsolete when there is no real reason to use them. PL/1 is obsolete. It's hard to find even legacy code using it, and nobody would use it for experimentation.

Roman empire is obsolete. Men can't stop thinking about it.

mostly because everything relevant we have today was built on smalltalk ideas and it still executed them better in the 70s than modern languages do today.

In what way, obsolete? There is quite a bit of worthwhile research done in Smalltalk-related languages and some corporations are quite successful in building on such languages.

It's not dominant in the way of Wordpress but also not insignificant.