Funding Unsuccessful This project’s funding goal was not reached on .
Photo-main
Play
00:00
00:00

Zeta Code is a new way of visualizing and interacting with software. View your code-base from 10,000 ft, and zoom down to any method.

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

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

Time-frame

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.

Comments?

I would really appreciate any comments or questions you might have.

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.

    Last updated:
  • 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.

    Last updated:
  • Yes. Zeta Code is written in Java, so it's cross-platform.

    Last updated:
  • 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.

    Last updated:
11
Backers
$267
pledged of $15,000 goal
0
seconds to go
  • Pledge $15 or more
    You selected

    5 backers

    A license for Zeta Code as a finished product + get added to the list of contributors.

    Estimated delivery:
  • Pledge $25 or more
    You selected

    1 backer

    The previous tier and access to a detailed User Manual in PDF, ePub, and .mobi formats (all larger pledge amounts will include this).

    Estimated delivery:
  • Pledge $35 or more
    You selected

    3 backers

    A license for Zeta Code + access to beta packages + get added to the list of contributors.

    Estimated delivery:
  • Pledge $60 or more
    You selected

    1 backer Limited (49 left of 50)

    Both the previous tier and a limited-edition Zeta Code T-shirt.

    Estimated delivery:
  • Pledge $100 or more
    You selected

    0 backers Limited (40 left of 40)

    A license for Zeta Code + access to beta packages + get added to the list of contributors + get invited to a feedback session (in google hangout or similar format)

    Estimated delivery:
  • Pledge $130 or more
    You selected

    0 backers Limited (10 left of 10)

    The previous tier + the T-shirt.

    Estimated delivery:
  • Pledge $200 or more
    You selected

    0 backers

    Small team: Five licenses of Zeta Code + be an early beta tester. You will have a chance to shape Zeta Code.

    Estimated delivery:
  • Pledge $500 or more
    You selected

    0 backers

    Medium Team: 15 licenses of Zeta Code + acknowledgment as a large backer of this project.

    Estimated delivery:
  • Pledge $1,000 or more
    You selected

    0 backers

    Large Team: 30 licenses of Zeta Code + acknowledgment as a large backer of this project.

    Estimated delivery:
  • Pledge $2,000 or more
    You selected

    0 backers Limited (5 left of 5)

    Huge: 50 licenses of Zeta Code + acknowledgment as a huge backer on the website for at least six months.

    Estimated delivery:
Funding period

- (25 days)