Project by

About this project

UPDATE: Immediate feedback with Groovy

UPDATE: Source code editor:

UPDATE: Quickly add nodes to a task

I'm a software developer who's been working professionally for at least seven years. My main programming language has been Java, although I'm also fluent in Javascript, Groovy, and Ruby. Over the years I've tried out lots of IDE's, but despite many advancements, the IDE still isn't much more than glorified text-editor.

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

Graphs

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

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.

Visual

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.

Dependencies

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.

Methods

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.

Context-switching

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.

Colors

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.

Gesture Programming

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.

Visualizing Relationships

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.

Languages Supported

I'm going to support Java, Groovy, and Javascript at first, but Zeta Code will be written so that other languages can be added through plugins. Depending on time and funds, I'd like to add more languages.

Why 15k?

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.

License

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.

Features Planned

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.

Comments?

FAQ

Parsing code into functions is the easy part, and will most likely be supported for just about any language (C, C++, Ruby, Python, etc.). The difficult part is integrating compiler support, error-checking, and especially "dynamic programming", which is why I've limited Zeta Code's scope to Java, Groovy, and Javascript at this time.

No. Zeta Code will have several ways of interacting with the keyboard, including standard concepts such as searching, keyboard-shortcuts, arrow-key navigation, and tab-navigation much like in browsers. I am keenly aware and sensitive to people with differing abilities and the dangers of repetitive motion injuries. Please let me know if there is a particular input device you need that I'm missing.

Zeta Code will be open-source. I'll be using open-source software, I believe in open-source, and as a developer I like having an open-source IDE now (Eclipse, among others), so Zeta Code will be open-source.