OK, having watched the video at https://www.youtube.com/watch?v=lqogvp1dGpk (8 minutes, so 4 minutes if you 2x it) I understand why they have such a hard time answering the question "What is Glamorous Toolkit?"
It's effectively a combination of a Smalltalk IDE, a Jupyter/Observable-style notebook environment and a tool somewhat like R Studio.
It's a hard thing to categorize, because it's not exactly the same kind of thing as anything else.
Part of the problem is that the way you use Smalltalk is pretty different from other programming languages already, due to the thing where you work within an "image" as opposed to just editing files on disk.
I emphasize with the challenge: I have a similar problem with my https://datasette.io/ project.
That's how this reads now. I had to read the GT page a few times before realizing it was a development environment for Smalltalk, specifically.
In general people who use a lot of buzzwords ('opinionated', 'beautiful' 'reactive') are trying to impress other developers already in their space. The more they use, the more alienating it is to interested general reader who doesn't have time to parse all this social coding and just wants information about a new topic.
This project looks great (for people who use Smalltalk), but the text does a poor job of communicating what it does and why you might want to use it. Even if you want to write a technical blogpost that gets into the weeds, there should be one plainly written short paragraph that summarizes what it's about for the first-time visitor who has no prior context.
that’s called documentation and it is mostly read post-activation. What’s read during onboarding is the “quickstart”, and they only attempt it after they’ve decided the offering matches their problem
Glamorous seems like something no one asked for- aggregating a bunch of semi-related tools into a jack-of-all trades platform. I don't understand who it is for
It's meant as an environment in which developers can build tools for every single development problem they have. Literally. I know it can sound crazy, but that's what it is for. The claim is that this practice leads to a new way of programming called Moldable Development.
This may be too late to this thread to matter, but I've been dabbling with GT for a few months, and I like it so far.
I'm using a few of the modalities mentioned in the article.
I use it as for "Pharo development" / Smalltalk IDE. I've tried a few times to learn Pharo and Smalltalk, but I've stuck with GT more than I ever had with raw Pharo. It feels nicer graphically, and, most importantly, it lets me write notes about what I'm doing and exploring and save them as part of the image. That means I can open GT and continue right from where I left off, even if it's been a month since I looked.
I use it for "Personal knowledge management", mostly. Little projects and analyses that occur to me. Nothing fancy, things like writing up why it's easier to get heads-tails in a sequence of coin flips than heads-heads, with a bit of simulation, a writeup of the Markov chain, derivation of expected times, etc. I've done that many times before, but it feels good to have it all together in an aesthetically-pleasing form. Bits on game odds, leetcode-ish algorithms exploration, general computational fiddling.
Once I figured it out, I like the git integration for both code and notebook pages. That goes a long way to reassuring me that the things I do won't be lost. I still don't quite get the Metacello / BaselineOfX dependency management, but I'll get there.
I did a little API browsing, mostly following the "Exploring the GitHub REST API in 7'" video by Oscar Nierstrasz (https://www.youtube.com/watch?v=-vFwfwy5WZA). That series is excellent and I think does a good job of illustrating the power of the system and how it's different.
But, in general, it feels like a good "tool for thought".
The idea makes sense to me. It's basically Emacs, but using Smalltalk instead of Lisp. Instead of using plain text to create your user interface, you have access to a built-in UI toolkit. That's very neat!
What's more interesting to me is the fact that the Glamorous Toolkit UI looks perfectly crisp on my M1 MacBook screen, whereas the Pharo IDE is a blurry mess because it doesn't support "retina" screens. If GT is built on top of Pharo, then why does Pharo still not support high DPI screens?
GToolkit uses a completely parallel graphics stack to standard Pharo. The VM and library ecosystem are still there but the UI is rebuilt from scratch on a modern vector based toolkit.
The productivity of the GToolkit developers is impressive.
Having looked at the screenshots and read the text, I still have no idea what Glamorous Toolkit v1.0 is. If I had to guess, I'd say it's another attempt at 'notebook' style computing interfaces, but I suppose there's a reason the author is too coy to say that, so I am forced to conclude that I just don't know what it is, and the creator is unable or unwilling to tell me.
My current understanding is that it's similar to Emacs, but in this case it uses Smalltalk instead of Elisp.
It's an IDE who's selling point is that you should extend while coding.
If my day job uses Python, for example, is it pragmatic to use Glamorous Toolkit?
Yes, it has a few functions for editing code in some language .. but you get a lot more Python power from Intellij or Pycharm. I don't use Smalltalk but if I were, I would consider it, alongside Pharo or instead of Pharo.
If my day job used Rust, I’d be very interested in trying this. Live development with your code loaded gives you a lot of power that you don’t know you’re missing until you try it with a Common Lisp, Clojure or Smalltalk environment.
I fiddled with its python interop a bit. It's OK, but could use some expanding: it runs python code in a single venv that you'd need to populate with the packages you need. I couldn't find any support for switching venvs based on project directories, etc.
I could imagine using GT as a more hackable way to interact with code. You don't get the nice automatic features of a python IDE, but you could define graphical views for your objects, drill-down into sub-objects, and the like. But to do that, you'd also have to know some Smalltalk.
"Glamorous Toolkit is the Moldable Development Environment. Moldable Development is a new perspective on programming through which we create custom tools for every development problem. We find that this ability changes the very nature of programming."
It's an IDE that lets you easily create tools for experimenting with your code.
And, IIUC, a debugger that lets you define custom views for interesting data? For example, in the "GtLudoGame" image (the first image in the post), the rightmost picture is some sort of custom debugging view for a game state -- so you can visualize it directly as a board state, instead of as a dict or list or whatever.
Yes. That said, it took me a while using it to figure out that one non-obvious key feature here is that “easy” means that they’ve made it cheap enough where one automatically changes their behavior and actually does create ubiquitous custom tools, where in other systems extension is more an afterthought, or at least distinct from “regular programming”
The author is not unwilling to explain, he has lots of experience trying to explain and knows how hard it can be.
The best single sentence description, IMHO, is that GT (Glamorous Toolkit) is the current manifestation, implementation, proof of concept of the idea that making systems explainable through mouldable development is very powerful.
Furthermore it is a very nice tool in its own right (again IMHO).
Saying 'GT is x' where x is any of the subjects in the text is problematic. Most people will cling to one perspective, the one they are most familiar with or like the most, and mostly forget the other ones.
I've been reading much of this over the past day or so since I made the comment. I don't want to sound overly negative, but the author seems to think repetition of the phrase "moldable development" will imbue it with meaning, while my closest approach here is "notebook-style smalltalk ide."
Even when talking about "supporting" other languages, it's in terms of forcing everything into a smalltalk interface and then using that object model to introspect. None of the blog posts I've seen have convinced me that this isn't just Jupyter or Mathematica with a smalltalk kernel, and that's why I said what I did about the author's unwillingness to use common terms to describe the software. "Moldable development" doesn't mean anything.
Is it just me or does it come off as super condescending?
I feel that, if you can't explain to us concisely what the thing you've been working on for decades is about, that's a huge red flag. The most I can tell you after reading this page: it has something to do with software development, and my inclination to explore further is zero.
Sometimes it’s just hard to explain something concisely when it’s both rapidly evolving and different from people’s assumptions.
In 1992 it was quite hard to explain what the Internet is. Is it a protocol? Yes, a whole bunch of them actually. Is it yet another email system? Yes, among other things. Is it like a forum? Yes, there’s Usenet, but you can also use that from BBS’s that are not really part of “the Internet”. So do you dial in like on Compuserve? Yes, that’s one way. Does it have games? Yes, but very different ones (tries to explain MUDs).
At that point many a reasonable person has given up with the understanding that it’s some kind of networky thing with a bunch of geeky apps, and you need to be a full-time student to figure it out.
In retrospect it’s easy to think that obviously something like the WWW would come along and clear all this up. I don’t think it was obvious at all in that moment, especially when all the consumer traction was with products like Windows and the VC money was flowing into flashy digital entertainment stuff like CD-ROMs and cable TV walled gardens that were the opposite of the Internet.
I got onto the Internet in the 1992 you mention at university.
It was easy to describe - a way for humans and computers to communicate. For me it was 99% Newsgroups and FTP. [1]. People shrug and move on. Most don't get it. It's years later that it's commercially available, with software built into the OS (win 95). And then it was using the Web, NNTP and FTP are more-or-less obsolete now.
But the Internet is still the same - a way for humans and computers to communicate with each other.
[1] I downloaded world data via FTP from the CIA, and someone at JPL answered a newsgroup post I wrote. Mind literally blown.
Perhaps, and yet, I feel like this page still does a particularly bad job of explaining what this thing is. Especially to an audience full of hardcore nerds.
"Glamorous Toolkit (GT) is the Moldable Development Environment. Version 1.0 embodies more than 6 years of development and is the result of some 14 years of research. Our goal is to make systems explainable by means of custom tools created for each problem. Glamorous Toolkit makes this possible by making the creation of custom tools inexpensive and seamless."
It introduces a new concept: Moldable Development.
And it summarizes succinctly what it's about: creating custom tools for each development problem.
Both of these are being exemplified in the article.
"Glamorous Toolkit (GT) is a mature notebook-style integrated development environment. Our goal is to make systems explainable by means of custom tools created for each problem. Glamorous Toolkit makes the creation of those tools inexpensive and seamless."
Please note I did not mention 'moldable development' because I can't figure out what it is supposed to mean. "Creating custom tools for each development problem" is usually just called "programming". Introducing a new product and trying to define a new concept should happen in separate paragraphs, at the very least.
That’s probably counting everyone who had an SMTP email address and/or Usenet access.
Those were commonly available via BBS’s and (in the case of email) via corporate systems, but it didn’t mean you had any ability to make IP connections yourself.
The first time I paid for dial-up Internet was 1993, I think. It was a very cheap provider. You’d dial to their Unix box with a terminal emulator, like a BBS.
Turned out the price was so cheap because they didn’t allow foreign IP connections at all! I could use IRC and connect to local ftp servers within my small European country, but that was basically it. I knew a bunch of people who were IRC addicts and this kind of local access was perfect for them, but I found it useless.
Did I have Internet access then? Technically I could use all the protocols. In practice it wasn’t really the Internet when connections to other countries just fail. The point I’m trying to make here is that “Internet access” in 1992 meant a lot of different things on a scale that doesn’t exist anymore.
No, the included demos have examples for a analyzing Ruby (ActiveRecord) and Java. There was a paper a while back about moldable development where they showed a Python debugger.
Yeah, I’m going to be giving this a spin pretty school to see how working on Ruby is like in it. It also gave me the idea of building a Swank client in smalltalk and maybe a McClim backend, but it’d be hard for me to give up emacs at this point.
The article was not meant to describe everything in GT. There is a whole book delivered in the environment to cover this. You can also see it here: book.gtoolkit.com.
In the second half of the article it says that those are just examples of what is possible, but the really interesting bit is that we build these tools for every single development problem, including when we deal with external systems or languages. And this leads to a new way of programming which we call Moldable Development.
I wasn’t expecting it to describe everything in GT. But I was hoping it would describe something about how these rust wrappers are implemented (or at least link to some code or docs). Being able to inspect your compiled machine code at a high level is really unique property I haven’t seen before and want to learn more about. I didn’t see anything about it in the book either.
I had a fun time exploring both Glamorous Toolkit & BlueSky's @proto with https://github.com/feenkcom/gt4atproto . Neat experience. Docs & code meld nicely. Very handsome on experience.
Glad to hear it. Would you like to tell us more about what you found interesting (either here or on our Discord)? I am asking because that's my favorite public use case so far :).
I tried for an hour to set this up once. The docs were all over the place, you needed prerequisites that were hard to find and linked to 404s. Mysterious errors. Eventually my curiosity was overcome and I gave up.
There's something called Gtoolkit, I think? I had to install NetBeans to get some plugin, to get one of these tools to work, then the plugin had some other requirements. It definitely wasn't just running their binary. It was a nightmare.
You can run it from anywhere including where you downloaded that has user write access.
But you have to keep everything in the top directory and copy that around not the .app
It is not packaged as a Mac Application that is all in a .app file which you can copy to /Applications. Most of the other files should be in ~/Application Support or ~/Documents to meet normal macOS directories.
Hmm, it should work just by downloading the ready made distribution in most systems without any other prerequisites. Would you like to detail what you tried? And what do you mean by 404?
OK, this is amazing, I was just thinking through on what to base a project that's been brewing in my head for weeks. This might do nicely.
Only problem is, I absolutely hate the GNOMEsque aesthetic.
Can't seem to find any info on changing its appearance. Of course it should be possible given the nature of the platform, but it really is offputting. The soft-corners and hamburger menu aesthetic really does not communicate what a powerful platform this is, and not being able to change it easily is really offputting.
It's effectively a combination of a Smalltalk IDE, a Jupyter/Observable-style notebook environment and a tool somewhat like R Studio.
It's a hard thing to categorize, because it's not exactly the same kind of thing as anything else.
Part of the problem is that the way you use Smalltalk is pretty different from other programming languages already, due to the thing where you work within an "image" as opposed to just editing files on disk.
I emphasize with the challenge: I have a similar problem with my https://datasette.io/ project.