I wonder if the benefits of GToolkit would go beyond using it to extend itself through Pharaoh. Would it be just as useful for writing C++ applications?
It has a C++ parser already, something could be built on top of that to help turn it into a proper C++ editor. Perhaps turn it into a structure editor. And it can start OS processes so you can use your existing build tools and such.
For example, there are connections to JS and Python out of the box for executing, inspecting and debugging. These are mere examples of what one can build with the environment.
In any case, the first target of our work is to help people discover and practice Moldable Development which is a generic approach to software engineering.
> I find the gtoolkit interface a little clunky in a way I can't quite describe
I would so love to expore with you what makes it feel clunky. Please do feel free to contact me directly https://twitter.com/girba.
I wonder if instead of binding to lua/angelscript, you could instead somehow expose the reverse engineered objects and such to this system to get a nice customizable/programmable UI.
I have 0 understanding of how this system functions at the implementation level, as in how much it relies on the underlying language/runtime/whatever. I know very little about Pharo or how it's actually implemented, just that it's inspired(?) by smalltalk (which I also know very little about). But it looks really cool and makes me excited thinking about the different possibilities that it could potentially open.
A lot of (some?)people are interested in modding games (with no mod support), but have no understanding of C/C++ or memory models. Trying to explain the levels of indirection of all the objects is difficult without visualization.
Are you the author? Where does the connection to the JS/Python runtimes happen? I looked through the github repos, but I am _very_ far out of my depth. I wanted to see what the API looked like, maybe it's something that could be implemented fairly easily.
The connection to other runtimes happens through an instantiating of a more generic proxy model. The same mechanism also enables us to connect with debugging interfaces as well. So, if you have a way to get the memory layout from a runtime, it should certainly be possible to play with it in GT.
Docs link: https://gtoolkit.com/docs/
I find the gtoolkit interface a little clunky in a way I can't quite describe but the core ideas are fascinating:
- if you're looking at a compiled method it's trivial to switch between different representations: you can easily look at the original source or the AST or the bytecode. It's also easy to write your own representations.
- the same applies to all other objects: it's easy to write views which let you query and visualize your application's object graph in the ways which are most useful to you
This sounds a lot like the lisp pitch: While you write your application you're also writing the tools which make it easy to write and debug your application. In Lisp you do this through molding the language; in GToolkit you do this through molding the IDE.