UPDATE: Immediate feedback with Groovy
UPDATE: Source code editor:
UPDATE: Quickly add nodes to a task
Zeta Code is a new way of creating and interacting with code. It visualizes a software project as both a graph and a fractal (using a ZUI), allowing you to view your project as a whole.
By graph, I'm referring to the mathematical definition. For example, each method would be a node in a call-hierarchy graph. In practice, your code-base typically depends on several open-source or closed-source libraries as well. Zeta Code visualizes each dependency as a node in a graph at the highest level.
Fractals are typically self-similar patterns, where self-similar means they are "the same from near as from far." In this sense, a software project is a fractal by design. We group files in directories, and each code file is a group of methods.
Zeta Code aims to visualize your code-base as a cohesive whole in a way that is both visually appealing and rewarding. It will embed as much information as possible visually so you can do in seconds what used to take hours. At first glance you should be able to tell where you might have too many methods in one class, which parts of your project are under-tested, which parts are used the most and least, and more. The size of each node corresponds to the size of the file or directory it represents. The shape of each node represents what it is (file, method, module or package) and the color will represent the status of the node (passing/failing, % tested, and amount of usage). You will be able to rotate and zoom and navigate easily.
Any sort of project tends to depend on several other projects and there are tons of frameworks for managing dependencies (Maven, Gradle, and RubyGems to name a few). Zeta Code builds this concept into the IDE.
The smallest unit of code is the method, not a file. Zeta Code allows you to think at a higher level by breaking each method/function into its own editor.
Switching between tasks will be a first-rate feature in Zeta Code, not an after-thought. Every time you start editing a file, a temporary Task will be created if you have not already selected one. A Task will be related to a group of nodes so you can return to them at any time.
In Zeta Code, I want to embed as much information as possible visually. To do this we need to utilize not just position, size, and shape, but also color and texture.
Sonar makes use of Hue from green to red to represent tons of different things from %Comments to Test-Coverage. I'd like to use each dimension in the HSV color-space to represent something different (limited to within a subset of the range so black/white are not used of course).
You'll be able to choose from multiple color schemes or write your own.
As alluded to in the video, adding, removing, and refactoring code will all be done through gestures. For example, clicking and dragging in a blank space would create a package, class, dependency, method, or even a method-call depending on the context.
You should be able to visualize code at a higher level. Zeta Code will make this possible. Here is an example of visualizing method calls:
The yellow end of the line represents the calling method and blue, the method being called. Although right now it's limited to within a class, I'd like to see this concept generalized. This could also apply to dependency visualizations, field access, and, of course, inheritance.
Coding without Blinders
I was also inspired by Bret Victor's talk to put in immediate feedback while coding. Basically, in Java, this consists of modifying the byte code to analyze each line and showing the results side-by-side as demonstrated in the video.
I'm going to need some help to build the IDE I have in mind. Any additional funds after physical rewards and taxes will be used towards a web-site, commissioning some professional graphics, and getting some help to build Zeta Code. Anything over the minimum amount will be used to make it more awesome.
How will you do it?
I'm not going to reinvent the wheel. Existing open-source libraries will be used when possible (for example, I've used the excellent neoeedit as the lightweight code editor). I've been working professionally for at least seven years, and I've written some open-source software including a game in Java.
Zeta Code will be/is open-source. In fact, an early version of it is already on github if you want to take a look yourself. By paying for a license, you're showing support for this project and helping it come to fruition. Also, you'll be informed whenever there's an update to Zeta Code in addition to the reward you choose.
Tasks/Working-sets: ability to save a group of files and return to them at any time.
Dependencies: Easily manage your dependencies. See which code is using what, and easily search for existing open-source software.
History: Navigate Forward/Backward easily (much like a browser).
Testing: Integration with modern testing frameworks like JUnit, TestNG, and spock.
Plugins: for version-control, compiling, testing, etc. It will be fully extensible.
Docs: ability to quickly see code-documentation by hovering, etc.
Call-hierarchy: see the methods called by current method and the methods that call it.
Refactoring: ability to rename methods, move methods by dragging, etc.
Preview: show real values in real-time ("coding without blinders" or "dynamic programming," as shown in the video).
Version Control: Support for git and svn at a minimum. Ability to animate much like Gource but with gravatars. (see below)
By building a completely new IDE, these features can be built so they work together as a cohesive unit, making the whole more than the sum of the parts.
Current plans, assuming the project is funded, are to have a working 1.0 in six months with a milestone release every month. Zeta Code will use semantic versioning.
I would really appreciate any comments or questions you might have.