13 ms·

Glamorous Toolkit

343 points by radeeyate 2y ago

throwaway743950 2y ago
Glamorous toolkit has always looked interesting to me, but feels a bit unapproachable. It just feels so foreign between smalltalk and a whole sort of philosophy that goes with it. For those with more experience, is it still relevant? Can the same be accomplished with python and jupyter notebooks?
- edwardog 2y ago
  Yes, still relevant. The same can be accomplished with other tools, but it will probably be more difficult. The idea of Glamorous Toolkit is that it’s a collection of tools you use to solve software problems by making little explanatory tools. You might start out with some bigger problem like “I need to make this service fast”, come up with a question like “what does the flow of data I care about look like through the service?” and then try to answer that question by making tools that could analyze/visualize logging output or a stack trace or whatever makes sense in your software’s context. The technique of “making little tools that explain to help answer a question” is Moldable Development, similar to how Test Driven Development is “make a failing big feature test loop, write little tests and make them pass until the big one passes”. You can make little tools to explain away questions you have while you’re working with plugins or shell scripts or whatever you’re comfortable with and that’s “Moldable Development”. The Glamorous Toolkit just happens to be a nice system of tools that make it easy to make more little tools to help explain away problems. Hope that helps! Lmk if you want to see some examples. Source and bias: I worked closely with the developers before I had to take a break from work and computer stuff.
  - seagreen 2y ago
    What a great idea. I believe in this a trillion percent, due to the personal experience of watching myself and a stronger developer tackle similar problems at the same time. I relied on my brain and the standard tools of my system. He of course did the same, but also made a custom visualizer for the core of the algorithm. Night and day improvement! So I'm a believer in the principles. But I'm also curious about throwaway743950's question. What are the things in the Glamorous Toolkit that concretely make it better for this style of programming than traditional tools? You say "[it] just happens to be a nice system of tools that make it easy to make more little tools", but that's got to be downplaying it. Switching environments is an agonizingly costly thing to do. What rewards await those who make the jump? Rubies? Emeralds? Custom views-with-nested-sub-custom-views? Curious (but not yet won over) readers want to know.
  - g00z 2y ago
    I would add one thing that makes GT very different from other tools and is very hard to recreate, is that these tools are ACTUAL objects and the things you see, are also ACTUAl objects, and not just a dummy representation of them as you see in other dataviz tools like plotting libraries or shell scripts. This means your tools and visualizations are just a specific context-specific view of your objects. Meaning you aren't limited in how these tools can interact with said objects, because you are never working with static data, it's always with the actual objects. It's hard to put into words, but it's similar to the difference between println debugging and a lisp repl or smalltalk debugger. They technically do the same thing but the actual implementation of them makes a world of difference.
    - skeledrew 2y ago
      Actually it wouldn't be difficult to add similar view protocols to Python objects as well (I used GT extensively a couple years ago). Pretty much everything is possible, but the live debugger and driller would be really difficult to replicate, which is where GT really shines for me. Alas it was just too much to properly bridge it with Python, where the majority of my work lies, and GT becomes overwhelmed when passed a fraction of data Python handles with ease.
      - g00z 2y ago
        Simple views sure, but tools like the driller or debugger are great examples of what I'm trying to highlight about when I say having the views work over actual objects is really important. Because if it wasn't for the fact the graphical stack was implemented as smalltalk objects, you couldn't build tools like the driller or debugger since they would have to be implemented as a secondary piece of software that loses the original context. Like for example, I built a custom tool for myself when I was working on this p2p network and had a section of the codebase with some non obvious control flow, since it was handling multiple different p2p networks at the same time. Normally this is where you include a diagram in the docs, but in about an hour I built a custom code editor for the class, that visualized all the control flow and explained the cases in a flow diagram by simply introspecting on the methods defined in the class. And this tool never fell out of sync like a static diagram, since it wasn't hardcoded by me. And from that point on, I worked within this tool whenever hanlding anything related to this. And fwiw, the python story is pretty seamless from my usage of it a few months ago. I was able to integrate and use python libraries into this project without much hassle.
  - ssivark 2y ago
    I think moldable development needs a few tutorials demonstrating concrete use cases. Without those it feels promising in the abstract, but I doubt many developers are able to connect with it and figure out how to actually use it. It feels so open ended that I wouldn’t know where to start. And I’ve actually spent several hours exploring Glamorous Toolkit!
    - tudorgirba 2y ago
      Thank you for the interest and for taking the time to explore the environment! There are quite a number of videos and explanations now, but we are still struggling to package them in a way that seems more approachable. We would need help with this. If you are interested, I would offer to have a session with you that we record and in which we go through your questions and I provide live explanations. Join us on Discord and we take it from there: https://discord.gg/FTJr9gP https://discord.gg/FTJr9gP
      - actionfromafar 2y ago
        Definitely needed. Grug want help. Grug not understand how do CRUD with Glamourous Toolkit. Grug want see.
        tudorgirba 2y ago
        Me here. Or on Discord. Can show :) Or look at: https://book.gtoolkit.com/working-with-the-postgresql-relational-dat-dyvymh09bdxh16sl4izn3zvo2 https://book.gtoolkit.com/working-with-the-postgresql-relati... (in the environment you can load the code which comes with live documentation)
      - verdverm 2y ago
        > but we are still struggling to package them in a way that seems more approachable Normal documentation pages on a website would be a good place to start. Don't bury them in a tool I have to download and fumble through
        2y ago
  - verdverm 2y ago
    > and then try to answer that question by making tools that could analyze/visualize logging output or a stack trace We already have industry standards for doing this. Why would I want to build some micro-tool/throw-away code to do what another tool does much better and battle tested?
    - smj-edison 2y ago
      1. In many cases you need something very specific that an existing tool doesn't do well 2. All the tools work together 3. All the tools are tracked in a central repository
      - verdverm 2y ago
        That's the pitch but it does not seem the reality. It seems like the exact opposite of unix philosophy, one tool to rule them all, rather than doing one thing really well. I can achieve the same with unix philosophy, using the tools and languages I already know.
        tudorgirba 2y ago
        Nice point. Indeed, it is possible to build tools elsewhere. The question is: do you build them, and if yes, when? What we show with GT is that it is possible to build such tools for every development problem. This leads to thousands of micro tools per system that should co-exist. GT is not a large tool to rule them all. In the Unix analogy, it is Unix, not one of the tools :). This still leaves the question of why would want to build those tools when there are standard tools already? Because systems are highly contextual. This means we can predict classes of problems but not specific ones, which then means that any clicking tool built before the problem is known will not be addressing the specificity of that problem. This is actually not that new of an idea. Testing is already done like that. We do not download tests from the web and run them on our system. We develop them as part of development after we know the problem. It's that contextualization that makes us stop every time a single test fails as we know that each of them captures something that our system specifically cares about. Now, a test is a tool. We can extend the same idea to any other tool. Does this address the question?
- ElevenLathe 2y ago
  I've played with GT and even pull it out every once in a while for small tasks, though I haven't in about 6 months. I think the idea is good, but it's a tough sell for working programmers because the whole culture of it is so foreign. I think there's a version of GT that would do well if it described itself in terms of paradigms working coders know (POSIX, IDEs, blub-y languages, text files) instead of in terms of SmallTalk. Maybe something nearly as cool can be done as a VSCode plugin? I personally think of it as kind of a supercharged Emacs for SmallTalkers.
  - tudorgirba 2y ago
    Thank you for giving it a try and suggestion. The first goal was to help us explore how far can the idea of contextual tools go. It helped discover what today we call Moldable Development. It is also the first extensive case study of Moldable Development, itself offering 5+K contextual tools that we used to develop the environment itself. And when we work on a system, we build thousands more. That said, now that we know what Moldable Development is, it can be copied. We want people to copy it. Our worry though is that we want people to copy everything, not only the visible parts. For example, I understand the Emacs parallel. But think of this: while Emacs can be extended, how many extensions do you actually use that are specific to your system? We literally use thousands. Per system. That quantitative difference leads to a qualitative difference and it's made possible because of the totality of the environment.
    - ElevenLathe 2y ago
      I think a supercharger changes a passenger car engine qualitatively too! So are there plans to copy GT/moldable development somewhere outside of Pharo/Smalltalk?
      - tudorgirba 2y ago
        Moldable Development is not specific to Smalltalk. We already show how it works for other languages. Some ideas are already inspiring other environments, like Clerk. In the meantime, consider GT as an extensive blueprint of what's possible. If there is one thing we learnt is that the technology is the smallest investment. The real investment is in learning how to exploit the idea of contextual tools for solving hard problems. That's what takes the longest, but the difference to how those problems are approached today can be measured in orders of magnitude.
nathan_compton 2y ago
I periodically check in on this and I can never understand what its really good for.
- kossae 2y ago
  Yeah I made a decent effort to dig in, as it seemed interesting, but I still have no idea what this is.
  - rizky05 2y ago
    [dead]
  - beefnugs 2y ago
    I feel like the reason this isn't an obvious big deal yet, is because we don't have in real life the ideal use case: which would be a really complex vehicle ( like a real world mech). Something that needs a bunch of tweakable manufacturer control systems, but also massive customization through customer code. And maybe this will never exist, because capitalism is all about vendor lock in.
    - photonthug 2y ago
      I think you're on to something here. Squeak/Pharo were/are in many ways an interesting and sort of obvious base for building things like IDEs, DAWs, CAD systems, other things that are heavy on interactivity, visualizations, and components. I don't know for sure, but it seems like there would be enough escape hatches for interoperability so it's not like you'd be actually be required to do everything in small talk, and certainly there's FFI (https://books.pharo.org/booklet-uffi/ https://books.pharo.org/booklet-uffi/ ). Empowering user customization and such is actually a big downside for commercial activities though. The last paragraph here ( https://en.wikipedia.org/wiki/Smalltalk#Image-based_persistence https://en.wikipedia.org/wiki/Smalltalk#Image-based_persiste... ) is directly raising the concern of how things can stay proprietary. Besides that.. increasingly devs themselves are very commercial and not exactly in it for the love of the game. They are actively hostile towards stuff that isn't pushed on them by business, and not very interested in creative activity that pushes the bounds of the possible. I think you can see some of this in the insistence on "it's just a notebook" comparisons here, but before that.. docker was also "just another VM" to most until it was absolutely too big to ignore. It's more than comparing to what you know, it's almost actively refusing to be curious / interested. So maybe it's burnout from unnecessary churn in tech, or maybe people just resist entertaining the idea that interesting new ideas are even possible until it's pretty directly affecting their ability to be hired. Maybe both.
WillAdams 2y ago
Previous discussions: https://news.ycombinator.com/item?id=33267518 https://news.ycombinator.com/item?id=33267518 https://news.ycombinator.com/item?id=23569799 https://news.ycombinator.com/item?id=23569799 https://news.ycombinator.com/item?id=42987951 https://news.ycombinator.com/item?id=42987951 https://news.ycombinator.com/item?id=23235120 https://news.ycombinator.com/item?id=23235120 It's something I've been considering for my current project: https://github.com/WillAdams/gcodepreview https://github.com/WillAdams/gcodepreview as I reach the limits of Literate Programming and so forth, but not convinced that the added overhead will pay off. Does anyone have a before-and-after of a project where this has been really useful? Bonus points if in Python.
- tudorgirba 2y ago
  Thanks for the links :). I'd be interested to learn more about the kinds of things you'd expect to get from using Glamorous Toolkit for gcodepreview. The way I see it, one path would be to make the rendering happen directly in GT (perhaps through an external texture). This would then allow you to see the rendering as views in various Python objects.
  - WillAdams 2y ago
    I would hope this environment would facilitate programming by making it even easier to look up how a module/function was defined, and when developing code, to quickly/easily plot output graphically/interactively so as to see whether things are lining up or no. I actually need a data visualization tool at my day job, so I've installed it there, and begun working through the documentation/tutorials --- hopefully it will facilitate my wrapping my mind around a better solution for a recursive description of systems at work _and_ making a graphical interactive version available to co-workers --- if that works out, I'll try it out on my personal project.
    - tudorgirba 2y ago
      Great to hear! I would be happy to learn more about the specific need you see in your work context. Either here or on our Discord. If you are interested to learn more about kinds of problems and how it fits in the development environment, perhaps take a look at the book I am writing in the open with Simon Wardley (we recently released the first four chapters): https://medium.com/feenk/rewilding-software-engineering-900ca95ebc8c https://medium.com/feenk/rewilding-software-engineering-900c...
photonthug 2y ago
Awesome. Had a feeling this was going to be a smalltalk thing. Seems to involve/extend moose[1] among other things. Judging from the comments and such interesting projects languishing in obscurity.. smalltalk / pharo[2] still has a PR problem even though I think a lot of people are kind of fascinated by the ideas of image-based persistence[3]. The typical easy comparisons to VMs, IDEs, and notebooks all seem to fail to capture an important part of the essence. Hence the need for new vocabulary like "moldable development" and "contextual micro tools" which is all part of the appeal and part of the problem. It really is a different kind of thing. I (still) hope it all catches on a bit more but my sense is that it probably needs to present itself as a bit less academic. Compare the moose touting of "meta-meta-modeling" with something like gritql[4], which focuses more on use-cases, and seems to be gaining in popularity rather than remaining obscure. Seems like maybe it's time for a change in tactics to bring in a wider audience. [1] https://en.wikipedia.org/wiki/Moose_(analysis) https://en.wikipedia.org/wiki/Moose_(analysis) [2] https://en.wikipedia.org/wiki/Pharo https://en.wikipedia.org/wiki/Pharo [3] https://en.wikipedia.org/wiki/Smalltalk#Image-based_persistence https://en.wikipedia.org/wiki/Smalltalk#Image-based_persiste... [4] https://github.com/getgrit/gritql https://github.com/getgrit/gritql
- theamk 2y ago
  When I visit that gritql link, the first line of "Usage" already tells me a lot: (1) what problems can it solve, (2) how do I use it and (3) what is entry threshold. This makes it a very cool tool which I am will be using in the future. That's for telling me about it! (In case you wonder, the answers I saw are: (1) semantics-aware code search/replace with no IDE requirement; or maybe better "grep" with no false positives (2) write queries on command line or in file, and pass them to tool; (3) very low: install the binary, there no need to "import" or "setup project" or any things like those). Compared to that into, Glamorous Toolkit presets itself much worse. Here were my thoughts when I opened the website: It seems to be some sort of data explorer tool, but it's also kinda weird. For example, the API explorer clearly shows post-processed data, so it's not actually exploring Github API, but rather some sort of binding to it (GhRepo according to the title).. so what's the use of API explorer which requires bindings to be written first? DevOps explorer seems interesting, but I don't care about Jenkins, so what I really want to see is how hard is it to teach it about new system. Maybe it's in the videos, but I am not going to watch long videos unless I am already interested in the tool. Maybe if I click around? Nope, and the blog is not very helpful too... In fact, the comments for the post were much more informative than the website, I love HN! So, apparently the answers are (1) it can visualize the data, if I am willing to learn smalltalk (2) it's smalltalk, so you create smalltalk classes, and they become stuck in the "image" that you cannot easily share with others nor use with any existing workflows and (3) it's probably a few hours of youtube (the first video alone is 45 minutes) + experimenting before I can get any useful output. I don't see it ever catching at all, sorry. Granted, it seems like a general problem with Smalltalk: the collaboration story is bad. It seems every Smalltalk user lives in their own little world, and sharing stuff with other people is an afterthought, at best. Just compare gritql's and GT's homepage: one starts with 3 copy-pasteable commands which would immediately show something cool, another starts with mysterious "Download" button followed by 45 minute video.
mindwok 2y ago
This comes across like someone's PhD project. It's unclear from reading the website what this is useful for and what it actually is.
- mindwok 2y ago
  Ok I went and watched the YouTube video. As a few others have mentioned, it seems analogous to iPython notebooks. Basically a bunch of tiny tools that augment your experience working with code, like showing dependencies as a graph, or letting you view dictionaries graphically.
  - tudorgirba 2y ago
    Thank you for taking the time. There is certainly similarity with notebooks. However, the notebook is only a part. For example, the notebooks are part of a knowledge base. They are multi-language. But the more interesting bit comes from how you can extend the environment to make it fit the context of your problem. For example, a prominent way to extend is by creating contextual inspector views for different objects. When taken as a whole, we end up with a new kind of a development experience that is centered around contextualizing the environment as part of development. It turns out that this is applicable to a wide range of problems. For example, the talk video from the page shows examples from several domains: - it starts by browsing the file system of a React project and then querying the external dependencies from a package.json - then it goes into static analysis of React components and their dependencies - then it shows how to explore the data of a REST API and document its usage - then it goes to work with GraphQL and show how to combine it with imperative code to explore data; and even here, we go a step deeper and answer the question of how the tool worked (i.e., what query was sent to the server when we do not specify pagination completely) - then it shows how we can work with Python by extending the inspector with Python code - then it shows how we can also change the editing experience as well and make it contextual - then it shows how we can document a domain model through executable examples that when combined with contextual views become documentation - then it shows how to work with the knowledge base and even post live to a social media from it through a dedicated snippet - then it shows how we can explain a Docker setup and how the commands were derived from templates - then it shows again social media interactions but this time by browsing posts in inspectors and querying the feed live - and finally it shows how we can have a dedicated editor for configurations defined in JSON that know how to highlight, complete and navigate based on the schema information Now, these are not features; they are just some ways you can use the environment for without the need for switching. The book from the environment shows even more such examples for inspiration. Each of these might look similar to some tool somewhere, but the possibility to have all of them in the same environment made out of the same pieces combined in many ways is the differentiator. Does this help in any way?
wisty 2y ago
So .... kind of like iPython notebooks but for building a system?
- tudorgirba 2y ago
  In a way. It does have a notebook component, but that's just one piece. It's the sum of all pieces that make it a different environment. From our point of view, the interesting bit is that we show that we can use the idea of contextual tools for every development problem at any abstraction level. That's counter intuitive, but we worked like this for 10 years and we did not find a counter example yet :)
curtisszmania 2y ago
[dead]
user3939382 2y ago
A couple years ago I spent about 2 hours trying to install this, crawling obscure dependencies, configs, special IDEs, etc before I gave up.
- kaeland 2y ago
  It’s a lot simpler to install nowadays. Just download, install, open the app, and voilà! Tons of self-executing examples are available within the notebook-style windows too. Hope this helps.
- akvadrako 2y ago
  I tried last year. Although the installation instructions were simplified, I couldn't get it to do anything but crash.
  - tudorgirba 2y ago
    Interesting. What operating system were you on?
henning 2y ago
OK, so it's like Python notebooks and Smalltalk. so it's like this dynamic thing for transforming data in a rapid feedback, ad hoc, exploratory fly-by-the-seat-of-your pants way. OK. why talk about "capturing domain knowledge" in videos where you're just making a class and sticking a variable in it? what does the class even do anyway if it's just a name with a field that's a bag of data?
- cess11 2y ago
  It's more like Spacemacs. An opinionated, programmable interface to an operating system that allows you to edit and execute text, browse the web, play git and so on. Just that it has a fleshed out GUI toolkit you interface with, unlike Spacemacs which is heavily text oriented. With the territory also comes that it's somewhat hard for newcomers to understand why the tool is important to longtime converts. The clear use cases seem mundane. 'You can edit text in it'. 'You can execute code in it'. 'It lets you debug programs'. To which one might respond: 'Yeah, so? Why do I need elisp/Smalltalk? My Electron app already does that and it doesn't come with weird Internet nerds.' If you get into it and later find that it helped you out to be able to deeply inspect or reprogram your notetaking, program execution, feed reader, git environment, then you'll start to think that it has something special. But that might take a while, and most of the way there you could just as well have used some other tool instead.
  - tudorgirba 2y ago
    That's an interesting way of putting it! Thanks.
gugagore 2y ago
Many comments are comparing Glamorous Toolkit to a JuPyteR notebook. It's worth noting that the comparison falls short because Glamorous Toolkit itself, including all of the UI [1], is implemented in the target language. [1] https://github.com/pharo-graphics/Bloc https://github.com/pharo-graphics/Bloc
- worthless-trash 2y ago
  I'm wondering how it falls short ? Just because its not python ?
  - JaumeGreen 2y ago
    It's the other way around. Python notebooks fall short compared to this because they don't have the same kind of interactivity with the data as GT has. A single tool in the toolkit is already equivalent to notebooks, at least from what I glimpsed at the introductory video. Then you have the rest of the tools, how it can easily inspect the objects, and probably manipulate them. This is probably one of the future ways in which we will work in programming in the future, when someone creates some similar tool, around a mainstream language, that can easily interact with LLMs, APIs, and data visualization tools.
    - tudorgirba 2y ago
      Well said! In fact, there is already LLM integration including programmable chats with the possibility of contextualizing the interface of each message in the chat :)
- tudorgirba 2y ago
  Nice point! The graphical part is one source of difference, but there others as well. For example, chapter 4 in the Rewilding Software Engineering that Simon Wardley and I are writing compares what we call defined explorations (as seen in Jupyter notebooks) with dynamic explorations (as experienced in Glamorous Toolkit): https://medium.com/feenk/rewilding-software-engineering-a3601a066e50 https://medium.com/feenk/rewilding-software-engineering-a360...
vivzkestrel 2y ago
I honestly saw all the screenshots and still dont understand even in the slightest bit what exactly your product does. Perhaps you picked a bad name or perhaps the copy on the website doesn't do justice to what the product actually does. Since you pasted some python code somewhere as example in one of the screenshots, I ll ask you a very simple question. I have a 50 line python program. I run your tool, what do I see?
- tudorgirba 2y ago
  Thanks for the question. You are not supposed to "run" the tool for your program. You start with a question about your program and then build a tool that shows it. Take a look here at an example of an explanation of a algorithm written in Python (we took Andrej Karpathy's tokenization algorithm): https://x.com/compose/articles/edit/1822723570574688256 https://x.com/compose/articles/edit/1822723570574688256 If you want more details of how it fits in the larger picture, take a look at chapter 4 of the book I am writing with Simon Wardley about Moldable Development: https://medium.com/feenk/rewilding-software-engineering-a3601a066e50 https://medium.com/feenk/rewilding-software-engineering-a360... If you have time and inclination to look at these, I'd be interested in feedback.
cess11 2y ago
It's much better packaged now than n years ago when I stumbled on installation and whatnot and gave up, that's great. If you like me don't like the font size, search the book for how to scale UI, the last snippet on that page show's how to do a global font size change. Plain Pharo is a really nice environment too.
Grumbledour 2y ago
I am so conflicted about this project every time it comes up. I think I understood for quite some time what it wants to do (Though when checking the website there always creeps in doubt, because it is so incomprehensible) and every year when I download the application again, it looks a bit more cleaner, a bit easier to just use. But still, basic things always elude me. Do I really have to read the handbook to figure out how to format text in the knowledge base? Half the windows and symbols just make no sense, etc. Try pressing a button to see what it does and now everything looks different and what even happened? It seems to glacially improve on that front and I know to really use it, I have to learn to program it, but I am also of the mind basic functionality should be self explanatory. And pharo itself as the basis of this seems so convoluted and complex, I wonder if I even want to get into this. And then, the community seems to solely be on discord still, and that is then always the point were I bow out and wonder if cuis smalltalk or other systems with simplicity as core tenant are not much nicer to use and I should look there. Of course, in the end, I never get more than surface deep into smalltalk, because while I want the tools to build my own environment, if I need to build them first, there is always more pressing work... But honestly, a great knowledge base and data visualization I can intuitively just use and then expand later on with my own programs sounds like a dream workspace. It's just, that it is really hard to get into at the moment. I don't know any python, but I could just use jupyter know and learn as I go, but sadly, I never get that feeling here.
- 7thaccount 2y ago
  I'm basically in the same boat with this and all the smalltalk systems I have tried. The environment is just so foreign. I get the gist for how programming works in pharo (have also looked at Squeak and Cuis), but Python just seems a lot more natural. It is also hard to find snippets of useful code on stack overflow for smalltalk for the things I want to do. Maybe copilot is better there. The more practical problem is I'd never be able to justify using any of this for corporate work.
  - sakesun 2y ago
    Even worse there are groups of people who keep praising it and keep us curious through these years. Yet none of remarkable applications built with it except the tool itself.
sakesun 2y ago
Project motto: "Make systems explainable through <unexplainable>contextual micro tools</unexplainable>"
- tudorgirba 2y ago
  Glamorous Toolkit only claims it can help with making systems explainable. Making writing in plain English explainable is out of scope :))
ilaksh 2y ago
I wonder if this was inspired to some degree by projects like Simonyi's Intentional Programming. https://en.wikipedia.org/wiki/Structure_editor https://en.wikipedia.org/wiki/Structure_editor https://martinfowler.com/bliki/ProjectionalEditing.html https://martinfowler.com/bliki/ProjectionalEditing.html Is gtoolkit the most advanced Projectional Editor or Structure Editor Editor so far?
- tudorgirba 2y ago
  Nice question. We were certainly aware of Intentional Programming. And indeed, Glamorous Toolkit does have a language workbench underneath with which we can create editing experiences for various technologies. But we started from the "reading" part of software engineering not from the "writing". That's because "reading" the system occupies the largest amount of development effort and it's the least optimized activity. Through contextual tools we can improve it manyfold. And this, it turns out, leads to a new way of "writing" as well. We call it Moldable Development.
  - verdverm 2y ago
    If you provide too many ways to do the same thing, people get confused. Like... I don't need a button or drag-n-drop to turn a function into a class function, I can just move the code or add the modifier in a normal text editor. Now, AI can do it for me with underspecified natural language, no need for an overly complex UI that takes so much effort to learn. I suspect this paradigm would be better served by nuking the implementation and reframing this around AI with tool usage. That seems where development is going
    - tudorgirba 2y ago
      Thanks for the suggestion. I would be curious to learn more about what you mean about "AI with tool usage". In any case, we wrote a bit about what we think of the intersection between Moldable Development and GenAI as explanations here: https://medium.com/feenk/rewilding-software-engineering-a3601a066e50 https://medium.com/feenk/rewilding-software-engineering-a360...
jamesrcole 2y ago
Some feedback on the webpage. "The goal? To make the inside of systems explainable. [image] caption: "The need for moldability is pervasive. The treemap shows the classes of Glamorous Toolkit organized in packages. Blue denotes classes that contain at least one contextual view; green shows those that have an example." I have no idea what that caption, nor the image, means, nor what it has to do with making the inside of systems explainable.
- tudorgirba 2y ago
  Thank you for the feedback. We removed the image and pushed the video up. Is this better?
  - jamesrcole 2y ago
    I think it’s probably for the better… but it’s a bit hard for me to judge. I don’t know much about the project, and didn’t understand those details, so I don’t know how important they were, or whether there is a better way to address the issues with what was there.
    - tudorgirba 2y ago
      I think it was not useful if it was not understandable. Thanks again for the feedback :).
  - mpascale00 2y ago
    Another HN reader confused here. I have no idea what this tool is or what it's for or how it's helpful from your website. I think it's a development and documentation tool of some sort, but even that took a little poking around to figure out. At first I thought perhaps this had to do with LLMs.
tylerjnewman 2y ago
Maybe this can be made into a mcp agent that was able to create tools that can be called by llm clients...
- tudorgirba 2y ago
  It certainly can :). In fact, you might not need MCP for that either. There already exist programmable abilities to work with LLMs within the environment.
gjvc 2y ago
people seem to miss that for technologies like this to succeed, it is not necessary for others to fail. interoperability is (or should be) the most important goal of all software. the fewer operating systems and environments there are, the lower the incentive to make portability a feature.
- tudorgirba 2y ago
  I am not sure what you mean exactly. GT works on all desktop OSes (and on Android). It works with Git for all sources. It can interoperate with the file system. It works with other runtimes like JS or Python. It works with the debugger adapter protocol to help accommodate other runtimes. It works with language servers, too. It even interoperates with an embedded webbrowser (through WebView on Mac and Windows) both ways. That's not quite a lack of interoperability, or?
  - gjvc 2y ago
    My point was not addressed to you, but rather to the comments which say that systems like this which are not mainstream are pointless. The fact that GT is as interoperable and portable as you describe, yet it still receives such comments shows how short-sighted many people in technology are, or have become. We are in violent agreement :-). I have watched your demos at UKSTUG and my jaw has been on the floor -- very impressive.
    - tudorgirba 2y ago
      Thanks for the clarification! I am sorry for the confusion. I am glad you found the demos interesting. I’d be interested what made them attractive from your point of view.
      - gjvc 2y ago
        The UI was particularly flexible and different data was visualised completely differently, that's all I immediately remember (it's been a while), but I don't remember being there being any limitation with data interactions ... You have now given me enough reason to binge watch all at https://www.youtube.com/@gtoolkit https://www.youtube.com/@gtoolkit :-)
16bytes 2y ago
I also have little idea what this project does or wants to do. Let's just talk about the homepage, especially the above-the-fold portion. > "Glamorous Toolkit is the Moldable Development Environment" So it's some sort of an IDE? What does moldable mean? > "Make systems explainable through contextual micro tools" What is a "system" in the context of an IDE? "Contextual micro tools" also sounds completely abstract. > "Each problem about your system is special. And each problem can be explained through contextual development experiences. Glamorous Toolkit enables you to build such experiences out of micro tools. Thousands of them ... per system. It's called Moldable Development." ... this does not help at all. Just more words without meaning. Next, there's the video. For somebody with zero context so far, why would they sit through a 46 min low quality video? tudorgirba - if this is your project, you really need to focus on getting the top half of the page right. People won't watch your video, no one will read your book if you can't give them a hook they understand. Use words and phrases with concrete and well understood meaning with adjectives: * Don't say "micro tool". Like Posix utilities? What is a tool? What makes it micro? * Don't say "contextual development". Isn't all development contextual? * "moldable" - no one knows what this means, don't force them to try and figure it out. * Don't say "system", it is too abstract. For example, "Glamorous Toolkit is an IDE for literate programming with first class support for interactive visualizations". If you can't get that sentence right, people just won't invest in learning more about your platform.
- tudorgirba 2y ago
  Thanks for taking the time to provide this detailed feedback! I agree that the message is not yet clear for most. We can see it in these threads quite well. Now, this is not the first one we are trying, and we will continue to try further :). The sentence you provide is certainly interesting because it is relatable. The problem is that it talks about a fraction of what we want to convey. At this point in time, as we do not know how to convey the idea succinctly, we are looking for people that will take the time to look at the more elaborate explanations. It turns out that there exist such people. It seems to me that you might be inclined to look at it, too. Please do let me know if you do. I would offer to show you around. And who knows, perhaps you can contribute a better presentation for what this is. What do you think?
dhab 2y ago
First time coming across this project and it's amazing!! Disclaimer: not used it, but certainly going to try it. Technology is too fragmented - day to day many of us depend on a ton of tools to go by our (work)days even for simple stuff. Log into console of X, Y & Z platform or tools (say X = Jira, Y = AWS, Z = repo) to introduce a new change/feature/bugfix whatever. Then switch to IDE of choice to eval code, then browser to read the docs, then Google/Claude to ask questions, and then be interrupted by a meeting, take notes, ... and on and on I see an opportunity here using something like this to unify your entire workflows/data-from-tools/tools into a uniform system you can query to get answers without having to jump through hoops (and give up). It appears investing time in building a repertoire of tools with something of this sort helps one automate or quicken chores (at work or at home even?) What else could you do with this apart from what's in the demos? Some "can it do this?" questions if anyone who has used this could helpfully answer are: * organise meeting notes across various topics and auto-compile a searchable "decision log" that you can drill in to dive into the context at a future date? * connect requirements (specified in excel) to JIRA tickets and Code? so you can jump back and forth in a single GUI * Log hours you have worked on something * create up to date management process reference / checklist along with escalation contacts, response templates, ability to engage others on roster, and later bring together all the information into a automated PIR timeline and other details * display system metrics of deployed services in AWS based on complex rules and provide local alert * maintain a schedule of your kid's swimming lessons * Notion like "verification expired" notifications * Live tables (say of stock market tickers)
- tudorgirba 2y ago
  > I see an opportunity here using something like this to unify your entire workflows/data-from-tools/tools into a uniform system you can query to get answers without having to jump through hoops (and give up). It appears investing time in building a repertoire of tools with something of this sort helps one automate or quicken chores (at work or at home even?) That intuition is quite right! If you look inside the environment, you will see multiple case studies. These are not things you do with the environment. These are things we've used the environment for. They are examples of what you can build. And if you look closer you will see different classes of problems. These are classes of problems for which the industry offers significant vertical solutions. Yet we show them addressed with much less energy, uniformly and much more contextualized. The idea is that if this is possible, it means it's also possible to produce tools for arbitrary combinations of problems. If you intend to explore it further, please do let us know how it goes.
dude01 2y ago
I love the ideas presented, and it really highlights how current IDE's have removed power from users. I think (from only reading and watching some videos) that this Glamorous Toolkit is a hybrid between Smalltalk IDE and C.A.S.E. tools. However, I downloaded the app but cannot figure out how to view my own source code. None of the example videos that I can find, show me how to use an existing local git checkout of source code.
daveguy 2y ago
PSA: if you're watching the video. Get through the first (or fast forward to) 2 min 3s... The audio quality is much improved at this point. At first I wasn't able to watch on 2x speed with all the noise, but at the 2min mark it was much better. https://m.youtube.com/watch?v=_ztGZpo9I9E&t=2m2s https://m.youtube.com/watch?v=_ztGZpo9I9E&t=2m2s
- tudorgirba 2y ago
  Indeed :). Thanks for watching. What do you think of it?
  - daveguy 2y ago
    I think these rapid feedback tools are great. And I love the idea of having tools show up in context. The only problem is that they seem to get unwieldy after a certain point. The view of all the different tools / libraries that come with it at the end of the presentation shows that. I have seen a few tools like this, and it seems like they would be more popular. Where you make changes in the code and you instantly see the effect. The ability to see diffs on data before and after looks very helpful. I learned oop with Smalltalk so the syntax and feel aren't a problem. I think code organization is the biggest weakness of the system. I like to zoom around a codebase in vi. Very cool concepts though. Do you have a list of these types of development environments? I recall one that was demonstrated on a graphical output and another "next phase" that was working out keeping up with different database sources. I believe it was a different group, but I can't remember the name of that one. Awesome work, and a field with massive potential. It's an environment that seems to work better than no-code and low-code environments.
    - tudorgirba 2y ago
      Thanks for the feedback. And for the kind words. >The only problem is that they seem to get unwieldy after a certain point. The view of all the different tools / libraries that come with it at the end of the presentation shows that. That view at the end does not show that they get unwieldy at all. It shows that the contextual tools were needed everywhere. If the cost of tools is so low that you can amortize the cost of a tool on the first use, you can literally throw them away after that first use. In fact that's the fate of most tools. Those thousands of tools that you can see in a GT distribution are those that proved to be reusable. Many more were not :) There were many tools that showed some visualization. But what we try to show with GT is that there exists a way to tackle arbitrary problems. This is possible because we see the environment itself as being a language made out of visual and interactive operators that can be combined in many ways.
ChicagoBoy11 2y ago
Reading through that website felt to me like trying to read the NKS book. It certainly feels like there's a there "there", but I'm either to unintelligent or can't devote the time to really get it, and then I move on
- tudorgirba 2y ago
  Thanks. It's certainly not about the reader's intelligence. At this moment, we do not know how to explain it succinctly. So, today it requires time. We are trying a different way of explaining starting with the overall problem of how to make decisions in software engineering in a book Simon Wardley and I are writing in the open. Perhaps it's of interest and sheds a bit more light: https://medium.com/feenk/rewilding-software-engineering-900ca95ebc8c https://medium.com/feenk/rewilding-software-engineering-900c...
acureau 2y ago
The jargon makes this project really difficult to understand at a glance. I've gathered that this is an environment for the programmatic inspection of existing systems. It is developed by a company that works heavily with legacy code, and they found that writing code to inspect a system was a faster way to answer questions about it than reading the source. That seems like a really cool approach. I still do not understand what "moldable development" means. To me this implies a different paradigm for building applications, which does not seem to be what's offered. I don't understand what a "micro tool" is, is it a unit of code? Am I missing something here?
- tudorgirba 2y ago
  Interesting questions! Glamorous Toolkit is indeed built by the team at feenk, which is a company. However, we created the company to fund the research, not the other way around. Everything we do is free and open-source. Our goal is not to build Glamorous Toolkit, but to validate the idea that what we call Moldable Development (programming through contextual tools) leads to explainable systems. We start from legacy systems because that's a hard problem that is not yet solved. If we are to find a new way of working, it should work in the least favorable conditions. With legacy systems, we have extreme combinations of technologies and inter-twinned domain knowledge that we have to make sense of. At first the approach was called humane assessment, but along the way we found that it actually does change forward engineering as well. For example, we've seen cases in which startups produce pitches for investors right from the development environment. Or teams that put a face on domain-driven design by showing the domain to business people from the development environment leading to co-development. Glamorous Toolkit itself is an extensive case study of Moldable Development, too. More recently, we also apply the same ideas to creating editing experiences as well. Imagine editors of generic languages that understand the framework or the domain and that offer inline activities. Yet another application area is that of code transformation. It turns out that we can describe large scale code transformations through contextual transformations as well. This then allows us to evolve large code bases seamlessly. This can work if creating a new experience is inexpensive. And this can be achieved if we can compose the overall experience out of tiny pieces. Micro tools like views in the inspector, custom debuggers, dedicated editors or even transformations. There are a few more details at moldabledevelopment.com including the beginning of an open book I am writing with Simon Wardley. Does this address your questions?
someguyfromital 2y ago
I would not take advice about how to make systems explainable by people that build such an incomprehensible website.
- tudorgirba 2y ago
  Thank you. We really do not advertise our marketing ability. Only that we are researchers and engineers that might have found a solution to a large engineering problem :). Or put it differently, would you rather take engineering advice from marketeers? :)
Confirm2754 2y ago
[dead]

343 points by radeeyate 2y ago

Glamorous toolkit has always looked interesting to me, but feels a bit unapproachable. It just feels so foreign between smalltalk and a whole sort of philosophy that goes with it. For those with more experience, is it still relevant? Can the same be accomplished with python and jupyter notebooks?

edwardog 2y ago
Yes, still relevant. The same can be accomplished with other tools, but it will probably be more difficult. The idea of Glamorous Toolkit is that it’s a collection of tools you use to solve software problems by making little explanatory tools. You might start out with some bigger problem like “I need to make this service fast”, come up with a question like “what does the flow of data I care about look like through the service?” and then try to answer that question by making tools that could analyze/visualize logging output or a stack trace or whatever makes sense in your software’s context. The technique of “making little tools that explain to help answer a question” is Moldable Development, similar to how Test Driven Development is “make a failing big feature test loop, write little tests and make them pass until the big one passes”. You can make little tools to explain away questions you have while you’re working with plugins or shell scripts or whatever you’re comfortable with and that’s “Moldable Development”. The Glamorous Toolkit just happens to be a nice system of tools that make it easy to make more little tools to help explain away problems. Hope that helps! Lmk if you want to see some examples. Source and bias: I worked closely with the developers before I had to take a break from work and computer stuff.
- seagreen 2y ago
  What a great idea. I believe in this a trillion percent, due to the personal experience of watching myself and a stronger developer tackle similar problems at the same time. I relied on my brain and the standard tools of my system. He of course did the same, but also made a custom visualizer for the core of the algorithm. Night and day improvement! So I'm a believer in the principles. But I'm also curious about throwaway743950's question. What are the things in the Glamorous Toolkit that concretely make it better for this style of programming than traditional tools? You say "[it] just happens to be a nice system of tools that make it easy to make more little tools", but that's got to be downplaying it. Switching environments is an agonizingly costly thing to do. What rewards await those who make the jump? Rubies? Emeralds? Custom views-with-nested-sub-custom-views? Curious (but not yet won over) readers want to know.
- g00z 2y ago
  I would add one thing that makes GT very different from other tools and is very hard to recreate, is that these tools are ACTUAL objects and the things you see, are also ACTUAl objects, and not just a dummy representation of them as you see in other dataviz tools like plotting libraries or shell scripts. This means your tools and visualizations are just a specific context-specific view of your objects. Meaning you aren't limited in how these tools can interact with said objects, because you are never working with static data, it's always with the actual objects. It's hard to put into words, but it's similar to the difference between println debugging and a lisp repl or smalltalk debugger. They technically do the same thing but the actual implementation of them makes a world of difference.
  - skeledrew 2y ago
    Actually it wouldn't be difficult to add similar view protocols to Python objects as well (I used GT extensively a couple years ago). Pretty much everything is possible, but the live debugger and driller would be really difficult to replicate, which is where GT really shines for me. Alas it was just too much to properly bridge it with Python, where the majority of my work lies, and GT becomes overwhelmed when passed a fraction of data Python handles with ease.
    - g00z 2y ago
      Simple views sure, but tools like the driller or debugger are great examples of what I'm trying to highlight about when I say having the views work over actual objects is really important. Because if it wasn't for the fact the graphical stack was implemented as smalltalk objects, you couldn't build tools like the driller or debugger since they would have to be implemented as a secondary piece of software that loses the original context. Like for example, I built a custom tool for myself when I was working on this p2p network and had a section of the codebase with some non obvious control flow, since it was handling multiple different p2p networks at the same time. Normally this is where you include a diagram in the docs, but in about an hour I built a custom code editor for the class, that visualized all the control flow and explained the cases in a flow diagram by simply introspecting on the methods defined in the class. And this tool never fell out of sync like a static diagram, since it wasn't hardcoded by me. And from that point on, I worked within this tool whenever hanlding anything related to this. And fwiw, the python story is pretty seamless from my usage of it a few months ago. I was able to integrate and use python libraries into this project without much hassle.
- ssivark 2y ago
  I think moldable development needs a few tutorials demonstrating concrete use cases. Without those it feels promising in the abstract, but I doubt many developers are able to connect with it and figure out how to actually use it. It feels so open ended that I wouldn’t know where to start. And I’ve actually spent several hours exploring Glamorous Toolkit!
  - tudorgirba 2y ago
    Thank you for the interest and for taking the time to explore the environment! There are quite a number of videos and explanations now, but we are still struggling to package them in a way that seems more approachable. We would need help with this. If you are interested, I would offer to have a session with you that we record and in which we go through your questions and I provide live explanations. Join us on Discord and we take it from there: https://discord.gg/FTJr9gP https://discord.gg/FTJr9gP
    - actionfromafar 2y ago
      Definitely needed. Grug want help. Grug not understand how do CRUD with Glamourous Toolkit. Grug want see.
      - tudorgirba 2y ago
        Me here. Or on Discord. Can show :) Or look at: https://book.gtoolkit.com/working-with-the-postgresql-relational-dat-dyvymh09bdxh16sl4izn3zvo2 https://book.gtoolkit.com/working-with-the-postgresql-relati... (in the environment you can load the code which comes with live documentation)
    - verdverm 2y ago
      > but we are still struggling to package them in a way that seems more approachable Normal documentation pages on a website would be a good place to start. Don't bury them in a tool I have to download and fumble through
      - 2y ago
- verdverm 2y ago
  > and then try to answer that question by making tools that could analyze/visualize logging output or a stack trace We already have industry standards for doing this. Why would I want to build some micro-tool/throw-away code to do what another tool does much better and battle tested?
  - smj-edison 2y ago
    1. In many cases you need something very specific that an existing tool doesn't do well 2. All the tools work together 3. All the tools are tracked in a central repository
    - verdverm 2y ago
      That's the pitch but it does not seem the reality. It seems like the exact opposite of unix philosophy, one tool to rule them all, rather than doing one thing really well. I can achieve the same with unix philosophy, using the tools and languages I already know.
      - tudorgirba 2y ago
        Nice point. Indeed, it is possible to build tools elsewhere. The question is: do you build them, and if yes, when? What we show with GT is that it is possible to build such tools for every development problem. This leads to thousands of micro tools per system that should co-exist. GT is not a large tool to rule them all. In the Unix analogy, it is Unix, not one of the tools :). This still leaves the question of why would want to build those tools when there are standard tools already? Because systems are highly contextual. This means we can predict classes of problems but not specific ones, which then means that any clicking tool built before the problem is known will not be addressing the specificity of that problem. This is actually not that new of an idea. Testing is already done like that. We do not download tests from the web and run them on our system. We develop them as part of development after we know the problem. It's that contextualization that makes us stop every time a single test fails as we know that each of them captures something that our system specifically cares about. Now, a test is a tool. We can extend the same idea to any other tool. Does this address the question?
ElevenLathe 2y ago
I've played with GT and even pull it out every once in a while for small tasks, though I haven't in about 6 months. I think the idea is good, but it's a tough sell for working programmers because the whole culture of it is so foreign. I think there's a version of GT that would do well if it described itself in terms of paradigms working coders know (POSIX, IDEs, blub-y languages, text files) instead of in terms of SmallTalk. Maybe something nearly as cool can be done as a VSCode plugin? I personally think of it as kind of a supercharged Emacs for SmallTalkers.
- tudorgirba 2y ago
  Thank you for giving it a try and suggestion. The first goal was to help us explore how far can the idea of contextual tools go. It helped discover what today we call Moldable Development. It is also the first extensive case study of Moldable Development, itself offering 5+K contextual tools that we used to develop the environment itself. And when we work on a system, we build thousands more. That said, now that we know what Moldable Development is, it can be copied. We want people to copy it. Our worry though is that we want people to copy everything, not only the visible parts. For example, I understand the Emacs parallel. But think of this: while Emacs can be extended, how many extensions do you actually use that are specific to your system? We literally use thousands. Per system. That quantitative difference leads to a qualitative difference and it's made possible because of the totality of the environment.
  - ElevenLathe 2y ago
    I think a supercharger changes a passenger car engine qualitatively too! So are there plans to copy GT/moldable development somewhere outside of Pharo/Smalltalk?
    - tudorgirba 2y ago
      Moldable Development is not specific to Smalltalk. We already show how it works for other languages. Some ideas are already inspiring other environments, like Clerk. In the meantime, consider GT as an extensive blueprint of what's possible. If there is one thing we learnt is that the technology is the smallest investment. The real investment is in learning how to exploit the idea of contextual tools for solving hard problems. That's what takes the longest, but the difference to how those problems are approached today can be measured in orders of magnitude.

nathan_compton 2y ago

I periodically check in on this and I can never understand what its really good for.

kossae 2y ago
Yeah I made a decent effort to dig in, as it seemed interesting, but I still have no idea what this is.
- rizky05 2y ago
  [dead]
- beefnugs 2y ago
  I feel like the reason this isn't an obvious big deal yet, is because we don't have in real life the ideal use case: which would be a really complex vehicle ( like a real world mech). Something that needs a bunch of tweakable manufacturer control systems, but also massive customization through customer code. And maybe this will never exist, because capitalism is all about vendor lock in.
  - photonthug 2y ago
    I think you're on to something here. Squeak/Pharo were/are in many ways an interesting and sort of obvious base for building things like IDEs, DAWs, CAD systems, other things that are heavy on interactivity, visualizations, and components. I don't know for sure, but it seems like there would be enough escape hatches for interoperability so it's not like you'd be actually be required to do everything in small talk, and certainly there's FFI (https://books.pharo.org/booklet-uffi/ https://books.pharo.org/booklet-uffi/ ). Empowering user customization and such is actually a big downside for commercial activities though. The last paragraph here ( https://en.wikipedia.org/wiki/Smalltalk#Image-based_persistence https://en.wikipedia.org/wiki/Smalltalk#Image-based_persiste... ) is directly raising the concern of how things can stay proprietary. Besides that.. increasingly devs themselves are very commercial and not exactly in it for the love of the game. They are actively hostile towards stuff that isn't pushed on them by business, and not very interested in creative activity that pushes the bounds of the possible. I think you can see some of this in the insistence on "it's just a notebook" comparisons here, but before that.. docker was also "just another VM" to most until it was absolutely too big to ignore. It's more than comparing to what you know, it's almost actively refusing to be curious / interested. So maybe it's burnout from unnecessary churn in tech, or maybe people just resist entertaining the idea that interesting new ideas are even possible until it's pretty directly affecting their ability to be hired. Maybe both.

WillAdams 2y ago

Previous discussions: https://news.ycombinator.com/item?id=33267518 https://news.ycombinator.com/item?id=33267518 https://news.ycombinator.com/item?id=23569799 https://news.ycombinator.com/item?id=23569799 https://news.ycombinator.com/item?id=42987951 https://news.ycombinator.com/item?id=42987951 https://news.ycombinator.com/item?id=23235120 https://news.ycombinator.com/item?id=23235120 It's something I've been considering for my current project: https://github.com/WillAdams/gcodepreview https://github.com/WillAdams/gcodepreview as I reach the limits of Literate Programming and so forth, but not convinced that the added overhead will pay off. Does anyone have a before-and-after of a project where this has been really useful? Bonus points if in Python.

tudorgirba 2y ago
Thanks for the links :). I'd be interested to learn more about the kinds of things you'd expect to get from using Glamorous Toolkit for gcodepreview. The way I see it, one path would be to make the rendering happen directly in GT (perhaps through an external texture). This would then allow you to see the rendering as views in various Python objects.
- WillAdams 2y ago
  I would hope this environment would facilitate programming by making it even easier to look up how a module/function was defined, and when developing code, to quickly/easily plot output graphically/interactively so as to see whether things are lining up or no. I actually need a data visualization tool at my day job, so I've installed it there, and begun working through the documentation/tutorials --- hopefully it will facilitate my wrapping my mind around a better solution for a recursive description of systems at work _and_ making a graphical interactive version available to co-workers --- if that works out, I'll try it out on my personal project.
  - tudorgirba 2y ago
    Great to hear! I would be happy to learn more about the specific need you see in your work context. Either here or on our Discord. If you are interested to learn more about kinds of problems and how it fits in the development environment, perhaps take a look at the book I am writing in the open with Simon Wardley (we recently released the first four chapters): https://medium.com/feenk/rewilding-software-engineering-900ca95ebc8c https://medium.com/feenk/rewilding-software-engineering-900c...

photonthug 2y ago

Awesome. Had a feeling this was going to be a smalltalk thing. Seems to involve/extend moose[1] among other things. Judging from the comments and such interesting projects languishing in obscurity.. smalltalk / pharo[2] still has a PR problem even though I think a lot of people are kind of fascinated by the ideas of image-based persistence[3]. The typical easy comparisons to VMs, IDEs, and notebooks all seem to fail to capture an important part of the essence. Hence the need for new vocabulary like "moldable development" and "contextual micro tools" which is all part of the appeal and part of the problem. It really is a different kind of thing. I (still) hope it all catches on a bit more but my sense is that it probably needs to present itself as a bit less academic. Compare the moose touting of "meta-meta-modeling" with something like gritql[4], which focuses more on use-cases, and seems to be gaining in popularity rather than remaining obscure. Seems like maybe it's time for a change in tactics to bring in a wider audience. [1] https://en.wikipedia.org/wiki/Moose_(analysis) https://en.wikipedia.org/wiki/Moose_(analysis) [2] https://en.wikipedia.org/wiki/Pharo https://en.wikipedia.org/wiki/Pharo [3] https://en.wikipedia.org/wiki/Smalltalk#Image-based_persistence https://en.wikipedia.org/wiki/Smalltalk#Image-based_persiste... [4] https://github.com/getgrit/gritql https://github.com/getgrit/gritql

theamk 2y ago
When I visit that gritql link, the first line of "Usage" already tells me a lot: (1) what problems can it solve, (2) how do I use it and (3) what is entry threshold. This makes it a very cool tool which I am will be using in the future. That's for telling me about it! (In case you wonder, the answers I saw are: (1) semantics-aware code search/replace with no IDE requirement; or maybe better "grep" with no false positives (2) write queries on command line or in file, and pass them to tool; (3) very low: install the binary, there no need to "import" or "setup project" or any things like those). Compared to that into, Glamorous Toolkit presets itself much worse. Here were my thoughts when I opened the website: It seems to be some sort of data explorer tool, but it's also kinda weird. For example, the API explorer clearly shows post-processed data, so it's not actually exploring Github API, but rather some sort of binding to it (GhRepo according to the title).. so what's the use of API explorer which requires bindings to be written first? DevOps explorer seems interesting, but I don't care about Jenkins, so what I really want to see is how hard is it to teach it about new system. Maybe it's in the videos, but I am not going to watch long videos unless I am already interested in the tool. Maybe if I click around? Nope, and the blog is not very helpful too... In fact, the comments for the post were much more informative than the website, I love HN! So, apparently the answers are (1) it can visualize the data, if I am willing to learn smalltalk (2) it's smalltalk, so you create smalltalk classes, and they become stuck in the "image" that you cannot easily share with others nor use with any existing workflows and (3) it's probably a few hours of youtube (the first video alone is 45 minutes) + experimenting before I can get any useful output. I don't see it ever catching at all, sorry. Granted, it seems like a general problem with Smalltalk: the collaboration story is bad. It seems every Smalltalk user lives in their own little world, and sharing stuff with other people is an afterthought, at best. Just compare gritql's and GT's homepage: one starts with 3 copy-pasteable commands which would immediately show something cool, another starts with mysterious "Download" button followed by 45 minute video.

mindwok 2y ago

This comes across like someone's PhD project. It's unclear from reading the website what this is useful for and what it actually is.

mindwok 2y ago
Ok I went and watched the YouTube video. As a few others have mentioned, it seems analogous to iPython notebooks. Basically a bunch of tiny tools that augment your experience working with code, like showing dependencies as a graph, or letting you view dictionaries graphically.
- tudorgirba 2y ago
  Thank you for taking the time. There is certainly similarity with notebooks. However, the notebook is only a part. For example, the notebooks are part of a knowledge base. They are multi-language. But the more interesting bit comes from how you can extend the environment to make it fit the context of your problem. For example, a prominent way to extend is by creating contextual inspector views for different objects. When taken as a whole, we end up with a new kind of a development experience that is centered around contextualizing the environment as part of development. It turns out that this is applicable to a wide range of problems. For example, the talk video from the page shows examples from several domains: - it starts by browsing the file system of a React project and then querying the external dependencies from a package.json - then it goes into static analysis of React components and their dependencies - then it shows how to explore the data of a REST API and document its usage - then it goes to work with GraphQL and show how to combine it with imperative code to explore data; and even here, we go a step deeper and answer the question of how the tool worked (i.e., what query was sent to the server when we do not specify pagination completely) - then it shows how we can work with Python by extending the inspector with Python code - then it shows how we can also change the editing experience as well and make it contextual - then it shows how we can document a domain model through executable examples that when combined with contextual views become documentation - then it shows how to work with the knowledge base and even post live to a social media from it through a dedicated snippet - then it shows how we can explain a Docker setup and how the commands were derived from templates - then it shows again social media interactions but this time by browsing posts in inspectors and querying the feed live - and finally it shows how we can have a dedicated editor for configurations defined in JSON that know how to highlight, complete and navigate based on the schema information Now, these are not features; they are just some ways you can use the environment for without the need for switching. The book from the environment shows even more such examples for inspiration. Each of these might look similar to some tool somewhere, but the possibility to have all of them in the same environment made out of the same pieces combined in many ways is the differentiator. Does this help in any way?

wisty 2y ago

So .... kind of like iPython notebooks but for building a system?

tudorgirba 2y ago
In a way. It does have a notebook component, but that's just one piece. It's the sum of all pieces that make it a different environment. From our point of view, the interesting bit is that we show that we can use the idea of contextual tools for every development problem at any abstraction level. That's counter intuitive, but we worked like this for 10 years and we did not find a counter example yet :)

curtisszmania 2y ago

[dead]

user3939382 2y ago

A couple years ago I spent about 2 hours trying to install this, crawling obscure dependencies, configs, special IDEs, etc before I gave up.

kaeland 2y ago
It’s a lot simpler to install nowadays. Just download, install, open the app, and voilà! Tons of self-executing examples are available within the notebook-style windows too. Hope this helps.
akvadrako 2y ago
I tried last year. Although the installation instructions were simplified, I couldn't get it to do anything but crash.
- tudorgirba 2y ago
  Interesting. What operating system were you on?

henning 2y ago

OK, so it's like Python notebooks and Smalltalk. so it's like this dynamic thing for transforming data in a rapid feedback, ad hoc, exploratory fly-by-the-seat-of-your pants way. OK. why talk about "capturing domain knowledge" in videos where you're just making a class and sticking a variable in it? what does the class even do anyway if it's just a name with a field that's a bag of data?

cess11 2y ago
It's more like Spacemacs. An opinionated, programmable interface to an operating system that allows you to edit and execute text, browse the web, play git and so on. Just that it has a fleshed out GUI toolkit you interface with, unlike Spacemacs which is heavily text oriented. With the territory also comes that it's somewhat hard for newcomers to understand why the tool is important to longtime converts. The clear use cases seem mundane. 'You can edit text in it'. 'You can execute code in it'. 'It lets you debug programs'. To which one might respond: 'Yeah, so? Why do I need elisp/Smalltalk? My Electron app already does that and it doesn't come with weird Internet nerds.' If you get into it and later find that it helped you out to be able to deeply inspect or reprogram your notetaking, program execution, feed reader, git environment, then you'll start to think that it has something special. But that might take a while, and most of the way there you could just as well have used some other tool instead.
- tudorgirba 2y ago
  That's an interesting way of putting it! Thanks.

gugagore 2y ago

Many comments are comparing Glamorous Toolkit to a JuPyteR notebook. It's worth noting that the comparison falls short because Glamorous Toolkit itself, including all of the UI [1], is implemented in the target language. [1] https://github.com/pharo-graphics/Bloc https://github.com/pharo-graphics/Bloc

worthless-trash 2y ago
I'm wondering how it falls short ? Just because its not python ?
- JaumeGreen 2y ago
  It's the other way around. Python notebooks fall short compared to this because they don't have the same kind of interactivity with the data as GT has. A single tool in the toolkit is already equivalent to notebooks, at least from what I glimpsed at the introductory video. Then you have the rest of the tools, how it can easily inspect the objects, and probably manipulate them. This is probably one of the future ways in which we will work in programming in the future, when someone creates some similar tool, around a mainstream language, that can easily interact with LLMs, APIs, and data visualization tools.
  - tudorgirba 2y ago
    Well said! In fact, there is already LLM integration including programmable chats with the possibility of contextualizing the interface of each message in the chat :)
tudorgirba 2y ago
Nice point! The graphical part is one source of difference, but there others as well. For example, chapter 4 in the Rewilding Software Engineering that Simon Wardley and I are writing compares what we call defined explorations (as seen in Jupyter notebooks) with dynamic explorations (as experienced in Glamorous Toolkit): https://medium.com/feenk/rewilding-software-engineering-a3601a066e50 https://medium.com/feenk/rewilding-software-engineering-a360...

vivzkestrel 2y ago

I honestly saw all the screenshots and still dont understand even in the slightest bit what exactly your product does. Perhaps you picked a bad name or perhaps the copy on the website doesn't do justice to what the product actually does. Since you pasted some python code somewhere as example in one of the screenshots, I ll ask you a very simple question. I have a 50 line python program. I run your tool, what do I see?

tudorgirba 2y ago
Thanks for the question. You are not supposed to "run" the tool for your program. You start with a question about your program and then build a tool that shows it. Take a look here at an example of an explanation of a algorithm written in Python (we took Andrej Karpathy's tokenization algorithm): https://x.com/compose/articles/edit/1822723570574688256 https://x.com/compose/articles/edit/1822723570574688256 If you want more details of how it fits in the larger picture, take a look at chapter 4 of the book I am writing with Simon Wardley about Moldable Development: https://medium.com/feenk/rewilding-software-engineering-a3601a066e50 https://medium.com/feenk/rewilding-software-engineering-a360... If you have time and inclination to look at these, I'd be interested in feedback.

cess11 2y ago

It's much better packaged now than n years ago when I stumbled on installation and whatnot and gave up, that's great. If you like me don't like the font size, search the book for how to scale UI, the last snippet on that page show's how to do a global font size change. Plain Pharo is a really nice environment too.

Grumbledour 2y ago

I am so conflicted about this project every time it comes up. I think I understood for quite some time what it wants to do (Though when checking the website there always creeps in doubt, because it is so incomprehensible) and every year when I download the application again, it looks a bit more cleaner, a bit easier to just use. But still, basic things always elude me. Do I really have to read the handbook to figure out how to format text in the knowledge base? Half the windows and symbols just make no sense, etc. Try pressing a button to see what it does and now everything looks different and what even happened? It seems to glacially improve on that front and I know to really use it, I have to learn to program it, but I am also of the mind basic functionality should be self explanatory. And pharo itself as the basis of this seems so convoluted and complex, I wonder if I even want to get into this. And then, the community seems to solely be on discord still, and that is then always the point were I bow out and wonder if cuis smalltalk or other systems with simplicity as core tenant are not much nicer to use and I should look there. Of course, in the end, I never get more than surface deep into smalltalk, because while I want the tools to build my own environment, if I need to build them first, there is always more pressing work... But honestly, a great knowledge base and data visualization I can intuitively just use and then expand later on with my own programs sounds like a dream workspace. It's just, that it is really hard to get into at the moment. I don't know any python, but I could just use jupyter know and learn as I go, but sadly, I never get that feeling here.

7thaccount 2y ago
I'm basically in the same boat with this and all the smalltalk systems I have tried. The environment is just so foreign. I get the gist for how programming works in pharo (have also looked at Squeak and Cuis), but Python just seems a lot more natural. It is also hard to find snippets of useful code on stack overflow for smalltalk for the things I want to do. Maybe copilot is better there. The more practical problem is I'd never be able to justify using any of this for corporate work.
- sakesun 2y ago
  Even worse there are groups of people who keep praising it and keep us curious through these years. Yet none of remarkable applications built with it except the tool itself.

sakesun 2y ago

Project motto: "Make systems explainable through <unexplainable>contextual micro tools</unexplainable>"

tudorgirba 2y ago
Glamorous Toolkit only claims it can help with making systems explainable. Making writing in plain English explainable is out of scope :))

ilaksh 2y ago

I wonder if this was inspired to some degree by projects like Simonyi's Intentional Programming. https://en.wikipedia.org/wiki/Structure_editor https://en.wikipedia.org/wiki/Structure_editor https://martinfowler.com/bliki/ProjectionalEditing.html https://martinfowler.com/bliki/ProjectionalEditing.html Is gtoolkit the most advanced Projectional Editor or Structure Editor Editor so far?

tudorgirba 2y ago
Nice question. We were certainly aware of Intentional Programming. And indeed, Glamorous Toolkit does have a language workbench underneath with which we can create editing experiences for various technologies. But we started from the "reading" part of software engineering not from the "writing". That's because "reading" the system occupies the largest amount of development effort and it's the least optimized activity. Through contextual tools we can improve it manyfold. And this, it turns out, leads to a new way of "writing" as well. We call it Moldable Development.
- verdverm 2y ago
  If you provide too many ways to do the same thing, people get confused. Like... I don't need a button or drag-n-drop to turn a function into a class function, I can just move the code or add the modifier in a normal text editor. Now, AI can do it for me with underspecified natural language, no need for an overly complex UI that takes so much effort to learn. I suspect this paradigm would be better served by nuking the implementation and reframing this around AI with tool usage. That seems where development is going
  - tudorgirba 2y ago
    Thanks for the suggestion. I would be curious to learn more about what you mean about "AI with tool usage". In any case, we wrote a bit about what we think of the intersection between Moldable Development and GenAI as explanations here: https://medium.com/feenk/rewilding-software-engineering-a3601a066e50 https://medium.com/feenk/rewilding-software-engineering-a360...

jamesrcole 2y ago

Some feedback on the webpage. "The goal? To make the inside of systems explainable. [image] caption: "The need for moldability is pervasive. The treemap shows the classes of Glamorous Toolkit organized in packages. Blue denotes classes that contain at least one contextual view; green shows those that have an example." I have no idea what that caption, nor the image, means, nor what it has to do with making the inside of systems explainable.

tudorgirba 2y ago
Thank you for the feedback. We removed the image and pushed the video up. Is this better?
- jamesrcole 2y ago
  I think it’s probably for the better… but it’s a bit hard for me to judge. I don’t know much about the project, and didn’t understand those details, so I don’t know how important they were, or whether there is a better way to address the issues with what was there.
  - tudorgirba 2y ago
    I think it was not useful if it was not understandable. Thanks again for the feedback :).
- mpascale00 2y ago
  Another HN reader confused here. I have no idea what this tool is or what it's for or how it's helpful from your website. I think it's a development and documentation tool of some sort, but even that took a little poking around to figure out. At first I thought perhaps this had to do with LLMs.

tylerjnewman 2y ago

Maybe this can be made into a mcp agent that was able to create tools that can be called by llm clients...

tudorgirba 2y ago
It certainly can :). In fact, you might not need MCP for that either. There already exist programmable abilities to work with LLMs within the environment.

gjvc 2y ago

people seem to miss that for technologies like this to succeed, it is not necessary for others to fail. interoperability is (or should be) the most important goal of all software. the fewer operating systems and environments there are, the lower the incentive to make portability a feature.

tudorgirba 2y ago
I am not sure what you mean exactly. GT works on all desktop OSes (and on Android). It works with Git for all sources. It can interoperate with the file system. It works with other runtimes like JS or Python. It works with the debugger adapter protocol to help accommodate other runtimes. It works with language servers, too. It even interoperates with an embedded webbrowser (through WebView on Mac and Windows) both ways. That's not quite a lack of interoperability, or?
- gjvc 2y ago
  My point was not addressed to you, but rather to the comments which say that systems like this which are not mainstream are pointless. The fact that GT is as interoperable and portable as you describe, yet it still receives such comments shows how short-sighted many people in technology are, or have become. We are in violent agreement :-). I have watched your demos at UKSTUG and my jaw has been on the floor -- very impressive.
  - tudorgirba 2y ago
    Thanks for the clarification! I am sorry for the confusion. I am glad you found the demos interesting. I’d be interested what made them attractive from your point of view.
    - gjvc 2y ago
      The UI was particularly flexible and different data was visualised completely differently, that's all I immediately remember (it's been a while), but I don't remember being there being any limitation with data interactions ... You have now given me enough reason to binge watch all at https://www.youtube.com/@gtoolkit https://www.youtube.com/@gtoolkit :-)

16bytes 2y ago

I also have little idea what this project does or wants to do. Let's just talk about the homepage, especially the above-the-fold portion. > "Glamorous Toolkit is the Moldable Development Environment" So it's some sort of an IDE? What does moldable mean? > "Make systems explainable through contextual micro tools" What is a "system" in the context of an IDE? "Contextual micro tools" also sounds completely abstract. > "Each problem about your system is special. And each problem can be explained through contextual development experiences. Glamorous Toolkit enables you to build such experiences out of micro tools. Thousands of them ... per system. It's called Moldable Development." ... this does not help at all. Just more words without meaning. Next, there's the video. For somebody with zero context so far, why would they sit through a 46 min low quality video? tudorgirba - if this is your project, you really need to focus on getting the top half of the page right. People won't watch your video, no one will read your book if you can't give them a hook they understand. Use words and phrases with concrete and well understood meaning with adjectives: * Don't say "micro tool". Like Posix utilities? What is a tool? What makes it micro? * Don't say "contextual development". Isn't all development contextual? * "moldable" - no one knows what this means, don't force them to try and figure it out. * Don't say "system", it is too abstract. For example, "Glamorous Toolkit is an IDE for literate programming with first class support for interactive visualizations". If you can't get that sentence right, people just won't invest in learning more about your platform.

tudorgirba 2y ago
Thanks for taking the time to provide this detailed feedback! I agree that the message is not yet clear for most. We can see it in these threads quite well. Now, this is not the first one we are trying, and we will continue to try further :). The sentence you provide is certainly interesting because it is relatable. The problem is that it talks about a fraction of what we want to convey. At this point in time, as we do not know how to convey the idea succinctly, we are looking for people that will take the time to look at the more elaborate explanations. It turns out that there exist such people. It seems to me that you might be inclined to look at it, too. Please do let me know if you do. I would offer to show you around. And who knows, perhaps you can contribute a better presentation for what this is. What do you think?

dhab 2y ago

First time coming across this project and it's amazing!! Disclaimer: not used it, but certainly going to try it. Technology is too fragmented - day to day many of us depend on a ton of tools to go by our (work)days even for simple stuff. Log into console of X, Y & Z platform or tools (say X = Jira, Y = AWS, Z = repo) to introduce a new change/feature/bugfix whatever. Then switch to IDE of choice to eval code, then browser to read the docs, then Google/Claude to ask questions, and then be interrupted by a meeting, take notes, ... and on and on I see an opportunity here using something like this to unify your entire workflows/data-from-tools/tools into a uniform system you can query to get answers without having to jump through hoops (and give up). It appears investing time in building a repertoire of tools with something of this sort helps one automate or quicken chores (at work or at home even?) What else could you do with this apart from what's in the demos? Some "can it do this?" questions if anyone who has used this could helpfully answer are: * organise meeting notes across various topics and auto-compile a searchable "decision log" that you can drill in to dive into the context at a future date? * connect requirements (specified in excel) to JIRA tickets and Code? so you can jump back and forth in a single GUI * Log hours you have worked on something * create up to date management process reference / checklist along with escalation contacts, response templates, ability to engage others on roster, and later bring together all the information into a automated PIR timeline and other details * display system metrics of deployed services in AWS based on complex rules and provide local alert * maintain a schedule of your kid's swimming lessons * Notion like "verification expired" notifications * Live tables (say of stock market tickers)

tudorgirba 2y ago
> I see an opportunity here using something like this to unify your entire workflows/data-from-tools/tools into a uniform system you can query to get answers without having to jump through hoops (and give up). It appears investing time in building a repertoire of tools with something of this sort helps one automate or quicken chores (at work or at home even?) That intuition is quite right! If you look inside the environment, you will see multiple case studies. These are not things you do with the environment. These are things we've used the environment for. They are examples of what you can build. And if you look closer you will see different classes of problems. These are classes of problems for which the industry offers significant vertical solutions. Yet we show them addressed with much less energy, uniformly and much more contextualized. The idea is that if this is possible, it means it's also possible to produce tools for arbitrary combinations of problems. If you intend to explore it further, please do let us know how it goes.

dude01 2y ago

I love the ideas presented, and it really highlights how current IDE's have removed power from users. I think (from only reading and watching some videos) that this Glamorous Toolkit is a hybrid between Smalltalk IDE and C.A.S.E. tools. However, I downloaded the app but cannot figure out how to view my own source code. None of the example videos that I can find, show me how to use an existing local git checkout of source code.

daveguy 2y ago

PSA: if you're watching the video. Get through the first (or fast forward to) 2 min 3s... The audio quality is much improved at this point. At first I wasn't able to watch on 2x speed with all the noise, but at the 2min mark it was much better. https://m.youtube.com/watch?v=_ztGZpo9I9E&t=2m2s https://m.youtube.com/watch?v=_ztGZpo9I9E&t=2m2s

tudorgirba 2y ago
Indeed :). Thanks for watching. What do you think of it?
- daveguy 2y ago
  I think these rapid feedback tools are great. And I love the idea of having tools show up in context. The only problem is that they seem to get unwieldy after a certain point. The view of all the different tools / libraries that come with it at the end of the presentation shows that. I have seen a few tools like this, and it seems like they would be more popular. Where you make changes in the code and you instantly see the effect. The ability to see diffs on data before and after looks very helpful. I learned oop with Smalltalk so the syntax and feel aren't a problem. I think code organization is the biggest weakness of the system. I like to zoom around a codebase in vi. Very cool concepts though. Do you have a list of these types of development environments? I recall one that was demonstrated on a graphical output and another "next phase" that was working out keeping up with different database sources. I believe it was a different group, but I can't remember the name of that one. Awesome work, and a field with massive potential. It's an environment that seems to work better than no-code and low-code environments.
  - tudorgirba 2y ago
    Thanks for the feedback. And for the kind words. >The only problem is that they seem to get unwieldy after a certain point. The view of all the different tools / libraries that come with it at the end of the presentation shows that. That view at the end does not show that they get unwieldy at all. It shows that the contextual tools were needed everywhere. If the cost of tools is so low that you can amortize the cost of a tool on the first use, you can literally throw them away after that first use. In fact that's the fate of most tools. Those thousands of tools that you can see in a GT distribution are those that proved to be reusable. Many more were not :) There were many tools that showed some visualization. But what we try to show with GT is that there exists a way to tackle arbitrary problems. This is possible because we see the environment itself as being a language made out of visual and interactive operators that can be combined in many ways.

ChicagoBoy11 2y ago

Reading through that website felt to me like trying to read the NKS book. It certainly feels like there's a there "there", but I'm either to unintelligent or can't devote the time to really get it, and then I move on

tudorgirba 2y ago
Thanks. It's certainly not about the reader's intelligence. At this moment, we do not know how to explain it succinctly. So, today it requires time. We are trying a different way of explaining starting with the overall problem of how to make decisions in software engineering in a book Simon Wardley and I are writing in the open. Perhaps it's of interest and sheds a bit more light: https://medium.com/feenk/rewilding-software-engineering-900ca95ebc8c https://medium.com/feenk/rewilding-software-engineering-900c...

acureau 2y ago

The jargon makes this project really difficult to understand at a glance. I've gathered that this is an environment for the programmatic inspection of existing systems. It is developed by a company that works heavily with legacy code, and they found that writing code to inspect a system was a faster way to answer questions about it than reading the source. That seems like a really cool approach. I still do not understand what "moldable development" means. To me this implies a different paradigm for building applications, which does not seem to be what's offered. I don't understand what a "micro tool" is, is it a unit of code? Am I missing something here?

tudorgirba 2y ago
Interesting questions! Glamorous Toolkit is indeed built by the team at feenk, which is a company. However, we created the company to fund the research, not the other way around. Everything we do is free and open-source. Our goal is not to build Glamorous Toolkit, but to validate the idea that what we call Moldable Development (programming through contextual tools) leads to explainable systems. We start from legacy systems because that's a hard problem that is not yet solved. If we are to find a new way of working, it should work in the least favorable conditions. With legacy systems, we have extreme combinations of technologies and inter-twinned domain knowledge that we have to make sense of. At first the approach was called humane assessment, but along the way we found that it actually does change forward engineering as well. For example, we've seen cases in which startups produce pitches for investors right from the development environment. Or teams that put a face on domain-driven design by showing the domain to business people from the development environment leading to co-development. Glamorous Toolkit itself is an extensive case study of Moldable Development, too. More recently, we also apply the same ideas to creating editing experiences as well. Imagine editors of generic languages that understand the framework or the domain and that offer inline activities. Yet another application area is that of code transformation. It turns out that we can describe large scale code transformations through contextual transformations as well. This then allows us to evolve large code bases seamlessly. This can work if creating a new experience is inexpensive. And this can be achieved if we can compose the overall experience out of tiny pieces. Micro tools like views in the inspector, custom debuggers, dedicated editors or even transformations. There are a few more details at moldabledevelopment.com including the beginning of an open book I am writing with Simon Wardley. Does this address your questions?

someguyfromital 2y ago

I would not take advice about how to make systems explainable by people that build such an incomprehensible website.

tudorgirba 2y ago
Thank you. We really do not advertise our marketing ability. Only that we are researchers and engineers that might have found a solution to a large engineering problem :). Or put it differently, would you rather take engineering advice from marketeers? :)

Confirm2754 2y ago

[dead]