SourceBinder is a lightweight framework to mix the programing method of node based editing and regular scripting in one environment.
Binder with the eye of a programmer
The simple idea behind Sourcebinder is not to have to rewrite any code block or class that was already done before, but to make those available as visual nodes that can be simply wired into a project making the recycling of classes as easy as possible. This solution results a framework, where most of the programing or even all of it is done visually by building a network of nodes, but every time when a given node or function is missing or just needs some customization the user is able to write just that specific code that implements the required behavior. This programing and also the compilation of the code is done in the environment itself and those custom built classes gets part of the framework immediately.
The framework has the ability to reach public variables and functions of every node at runtime. That on one hand makes realtime parameterization possible without having to recompile any code. But its biggest benefit is definitely the ability to bind these properties and functions with those of other node's.
The environment consists also of a built in playback function, that simply runs (plays) the program of the actual node graph, this way connecting, adjusting and reorganizing nodes can all be done on the fly and you can see the result in realtime.
The environment is somewhat similar to an UML Class Diagram editor, but instead of just designing a program before doing the implementation in a programing environment, in source binder the design is the implementation and coding, (scripting) parameter adjusting and designing are just three different zoom levels (views) of the same, self explaining graph.
Source binder is a framework and a development method that could be used with many programing languages, and one of the future goals of SourceBinder is also to become an environment where the mixing of different programing languages is as easy as connecting two different type of nodes together, but the first version of SourceBinder was developed to be used for Flash programing and it uses the Flex 3 SDK .
An other advantage of SourceBinder is, that all of the compilation is done at server side. That takes a lot of struggle off the user, because this way he/she does not have to care about installing and configuring a new environment and managing all the packages and their versions. So the only thing a user needs for working with Binder is nothing else than a browser.
A node of Binder can be any compilable actionscript class. To make the importing of opensource libraries as easy as possible Binder has a small wizard, which generates a simple wrapper class around an imported element. So bringing new libraries into the framework doesn't even require any programing knowledge. This openness of Binder makes it in fact infinitely extensible.
Every project or node can be assigned public or private by its creator. By making reusable nodes public, all the members of the community will be able to use that given node, so with time binder could become a tremendous sharing place of creative common knowledge. Just imagine an environment where you can make use of all the opensource flash libraries out there, just by dragging a building block of that library to the stage and connecting it with whatever it makes sense.
To be an up to date designer, one has to know a lot of technologies and techniques and many times one would have to dive deep into programing. To learn all those techniques and skills one has to spend a lot of time reading references and manuals, spending too much effort on this side, which usually harms the creativeness. There are a lot of tools and environments which are about to help designers to manage their work without these special skills. In most cases though, this help is also the fall because usually it brings a lot of limitations. So it looks like programing and reading a lot can not be get around. There is a well known solution for this kind of problem, which is the more often used visual node based composing. With this technique one can create a program simply by dragging and connecting building blocks together. A composition created this way is in fact a graph, a network of nodes which processed the right way produces a program. Working with this method brings a lot of advantages, for just to mention a few: the graph is usually the best, self explaining visualization of a program which makes learning and understanding quite easy.
Experimenting which is a very important task in a creative process, can also be done ideally. And as a result of all the advantages node based visual environments are probably the best way to do rapid prototyping. But like all the times there are also some problems coming with all the advantages. Naturally visual frameworks come with a finite number of building blocks, so as a consequence it can happen that a function that would be badly needed is not part of the system. For a solution to this problem most of such environments come with an API, which enables the user to build new functional elements in to the framework. This as a fact is an ideal solution, but usually the struggle to do so is so hard and painful, beginning with the setting up of a special programing environment, studying of the tutorials and references, going on with building, configuring and publishing, so too often even experienced users get stuck at one point of this process. Probably this is the fist point where SourceBinder comes into view. In the framework of Binder, even when doing "just" composing you are in fact just a zoom level away from the source code of every given node. That means, every time you have to make some customization to a given node, or you would like to insert a new building block, you just have to zoom in to that specific zoom level, and this way you will find yourself immediately in the programing environment of the framework. So understanding how a specific node works, doing simple changes, or importing new functionality gets just simple and straightforward.
And because SourceBinder was completely built on flash technology, naturally all of the nodes are simple actionscript classes, so there is no need for learning some new language.
On the top of all the inserted code gets compiled in the background on the server, and you are able to use your compiled new node immediately. And if you assign your custom made node public all the other users of the framework can benefit from your work as well.
At the beginning SourceBinder comes with most of the intern flash functions built in as regular nodes, and some elements of todays favorite open source packages like Papervision 3d library, the WOW physics library, WiiFlash package to handle WiiMote and the as3glue package for dealing with physical computing.
As an output, sourcebinder generates standard Flash SWF file of your composition, but if you need you can also export the actionscript code which you will be able to use in any standard flash developing environment.