Comment by westoncb | Hacker News Reader

Comment by westoncb | Hacker News Reader

Parent Full thread

Damn, glad to see this, but they're also kinda encroaching on my territory! :P

I've been working on something like this that's language agnostic and works with not only tables but also trees, graphs, lists, hashmaps, etc., and animates the visuals as the data structures are modified in real time (and you can pause, playback, step, etc.): http://symbolflux.com/projects/avd

The api I was conceiving earlier was more complex, but if you read the copy there, you'll notice it's essentially the same now: `MObject.monitor(...)` or MTable.monitor() MStateMachine.monitor() etc.

Edit: really am happy to see some other projects like this in total, partly because I want to use 'em now if possible—but also because I've had a surprisingly hard time communicating to other developers why it might be desirable to do something like this in the first place, so I'll be very happy to have general awareness raised.

I read the first line of their docs as rather dry humor, "Displays tabular data as a table." —like yeah, of course you would want to see tabular data as a table, and hierarchical data as a tree, etc.!

At a quick glance it looks like it's targeted towards mutable data structures. Can it support (and would it make sense to support) immutable data? E.g. it would be nice to have a Haskell state monad that also visualizes its state.

You are correct, it's very much targeted toward mutable data structures. It'd be interested in looking more into the state monad and considering the possibilities, but I haven't yet.

Actually part of how I see the role of systems like this is part of the necessary conditions for more safely working with mutable data. I think mutable data is more risky, but also super easy to work with, so if we had ways of making it more reliable we should explore them. I envision languages where this sort of visualization is a core feature designed in tandem with the runtime etc.

Neat! Very interesting ideas! The Vacuum package[1] seems like something you could look into if you want to explore Haskell. Good luck with your project!

[1]: https://hackage.haskell.org/package/vacuum

Thanks! Looks pretty cool. I also found this: http://felsin9.de/nnis/ghc-vis/

Looks really interesting, which platforms languages etc. does it support?

There are two clients in progress at the moment. By far the more complete one is for Java; the other is for javascript.

Since I've had such a difficult time communicating the potential benefit of the fully general piece of software, I've been exploring applications that I can build on top of it which do visualizations for more specific things (rather than leaving it to folks' imaginations to roam the wide possibilities of general data structure visualization :)).

As an example, my sister and I started building a 'code tutor' app in Electron, where you would be presented with problem sequences—but when you tested the code for your solution, you could watch what your algorithm actually did to the data (imagine a failed attempt to sort a list). This was the motivation for writing the javascript client. I integrated Lucidity's visuals by running it headless and streaming frames over TCP to the Electron app.

I think the next thing I'm gonna do though is just finish general object monitoring for the Java client, so that you could get something a little like the Chrome dev tools object printer in Java—but of course this one will allow you to watch algorithms performed on your objects :)

Btw, source for the (rather incomplete) javascript client is here if anyone's curious: https://github.com/westoncb/JS-Watcher

This looks really cool and I would love to play with it but I can't seem to find any download link. Is it publicly available?

Unfortunately, no :/ I should get that together soon, but there are still some rough edges I've wanted to work on before issuing a release.

Cool.

A small suggestion: Allow to not show so much.

A problem I have with most log-like solutions is that them bombard you with so much info and you need parse them after the fact, yet none of the log visualization have a way for that (just ctrlf, with luck).

A simple improvenment? Put a search box in top of the displayer, and a way to make contextual search, (like :tree.at Code.py), and a way to save search patterns, so I can put the whole search syntaxt and just fill boxes (like :mySearch foo)

Hey mamcx—totally agree. Actually, I've got designs for something very much like what you suggest. I was actually thinking of designing a simple query language for it so that you could search for certain types of relationships etc. too.

This is amazing. I love it.

That video was impressive. Are you using OpenGL/gpu for the animations?

Yes, sadly I rolled my own engine directly on top of Java/OpenGL, rather than using something pre-existing. (There were some decent reasons for it considering how specialized the visuals I'm working with are—but it was a big mistake over all. Should've done it in a more prototype-y fashion).

To code the animations I use something in the engine which resembles CSS transitions and can be attached to arbitrary Java objects, which I call 'property modulators'. So most of the animation you see comes from setting up one of those on one property or another.

Would this possibly work on top of WebGL?

Most of the rendering code would be a pretty direct port—I don't think I'm using anything from OpenGL that isn't supported by WebGL. That said, it is a desktop Java application and it would be non-trivial to port it to javascript. And that said, it probably would've been best to do it in javascript in the first place, but I did basically no web dev when I started, so... shrug

Wow, super cool! How does this cope with cycles?

Reply on news.ycombinator.com