Curious about the hidden aesthetics of programming style and algorithms, I designed an architecture for the collection of execution data for visual representation.
In order to build a system that allows this type of data collection, I needed to build a system for the instrumentation of Java bytecodes. In other words, I've written an application that takes as input another Java application. The bytecodes of this application are analyzed, and execution statistics are collected based on various templates. The most simple and elegant of these templates is to collect data about procedure invocations, primarily because method calls are easy to detect in Java bytecode.
Because this system is template-directed, more complex sequences of bytecodes are able to be detected as well, but I will concentrate on procedure invocations within this document.
In contrast to similar projects focused on the visualization of code execution, this architecture is purely dynamic, and based on the actual execution of the program, as opposed to the purely speculative mechanisms based solely on static analysis of the program source code.
Trace 1: Execution of a recursive tree drawing algorithm.
Trace 2: Execution of a smoke particle rendering system.
Trace 3: Execution of a simple particle rendering system.
Trace 4: Same as trace #3, after reducing optical clutter and minimizing contrast between data.
Traces 5&6: Execution of a Koch fractal generating program. Again note the emergence of patterns
upon removing clutter and minimizing contrast.