Hacker News Reader

Comment by brian_cloutier | Hacker News Reader

This recent video does a good job of illustrating some of the power of what they've built: https://www.youtube.com/watch?v=jJhfTUSDlR0

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.

View on HN

It's really interesting to see all of this visualized. I used to do a subset of these things when I used to reverse engineer games. Reverse engineering all the object structures, injecting a DLL, pointing at those objects and then exposing them via lua or angelscript. Maybe making an interactive REPL like thing so I could play around with things.

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.

You can already connect Glamorous Toolkit to JS and Python to work with objects exposed by their runtimes :)

That's a different use case, where you have access to the source. I'm more thinking for exploring memory objects of games (that we don't have the source access too) to visualize the relationship between the objects in the game and help teach reverse engineering and memory models.

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.

Wow, I love the idea of using GT for reverse engineering. That would’ve been life-changing for my last experience, where I worked mostly in a hex editor. The context switching and slow feedback cycle were brutal. Documenting my growing understanding/implementation with live custom visualizations would’ve been awesome. Unfortunately, that was twenty years before I discovered GT!

Indeed, I am one of the authors :).

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.

Can you post a link to the docs regarding python? it isn't listen on the docs and this very comment comes in third place after the google search.

Docs link: https://gtoolkit.com/docs/

Indeed!

> 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.

> While you write your application you're also writing the tools which make it easy to write and debug your application.

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?

https://gtoolkit.com/docs/analyzing-cpp/

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.

People are using it for various systems and for a variety of use cases that go well beyond programming with Pharo.

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.

Why spend days of actual work when you can spend years automating / customizing your workflow

this is my curse actually

Ugh, do I fall into that rabbit hole often! The thing with GT, though, is that the cost of creating visualizations is so low - a few seconds - that it’s rarely a distraction

Reply on news.ycombinator.com