xodio / xod Goto Github PK
View Code? Open in Web Editor NEWXOD IDE
Home Page: https://xod.io
License: GNU Affero General Public License v3.0
XOD IDE
Home Page: https://xod.io
License: GNU Affero General Public License v3.0
Desks are a composition of widgets that could show some value or receive some input from a user. They kind of forms or console for xoders’ devices.
From another side, a desk is a patch node with inputs and outputs corresponding to its widgets. This node could be placed on a regular patch to hook it up.
Once the desk is hooked up to a patch of NodeJS target, its UI should be served on some port so that it is available for interaction with web-browser.
localhost
URL (printed in console)At the moment, we have a lot of modules, that we don't need or it performs approximately the same functions. For example, we have a lodash, underscore, and ramda in node_modules.
Of course, we didn't load everything into a client.bundle, but it's harder to decide what we shall use (and already used somewhere in code).
So I propose to remove all modules that we didn't use now, determine what shall we use (really it's not so big list) and then we'll add something else in the future if we forget something.
I looked at the modules and think that we can leave the following modules (or choose some of those that are written with a slash):
production:
development:
If you think that we need to add something in this lists or propose another module instead of those that in the list — feel free to write it in comments.
Are there any reasons we develop against Node 0.12.0 (maintenance only) instead of Node 6.0.0 (current stable)?
From package.json
:
"engines": {
"node": "0.12.0"
},
It would help a lot to understand what’s going on in a XOD program if I can view values on outputs I’m interested in real-time.
To achieve it we’re going to introduce xod/core/watch
node that has a single (unnamed) input of type string. When a debug session is active the watch shows the value passed as its body, i.e. instead of own label.
xod/core/watch
like a regular node on my patchNodeId
’sxod/core/watch
like a regular node that Serial.println(...)
in it’s evaluate
. A ctx
argument is passed to evaluate
it’s a node ID which we could use to correctly bind the data to a watch.+XOD:42=76.9859
plus line break, where 42 is a node ID and 76.9859
is input value (text)Make a button that would call a JS function (black box) with patch JSON.
Creating patch nodes is a most powerful way to evolve the user project and to extend the ecosystem. We should allow the user to create new nodes by combining existing.
A patch node implementation is a special kind of a patch that has unbound pins for inputs and/or outputs of the node as a whole.
The approximate user action steps are:
After that, I have a ready-to-use new patch node.
The patch node should appear in a list of node types available for insertion. Nodes placed such way get the same label as a patch nodes’ patch name and input/output pins that are not bound on its implementation patch.
Story acceptance criteria
Features to be implemented:
Are there any reasons we have a big bunch of various labels and no rules how to use them and when.
What if I remove all but few actually used for now?
Multilevel undo/redo with Ctrl+Z/Ctrl+Y
For mapping their hardware with UI
We could use AngularJS commit message conventions (https://gist.github.com/stephenparish/9941e89d80e2bc58a153) to make history more clear.
I don't think we should be very verbosive in body message until the release but other practices would be handy.
Valid pins of the same type (in bool/number/string meaning) as a linking pin should be highlighted green. Other valid pins should be highlighted yellow.
Following things should be implemented:
For valid linking see docs.
From user’s point of view:
*.xod
file to overwrite*.xod
file to be opened as a new project@scalamorphing @brusherru Do not use .jsx
extension uless it is a module containing <ReactXmlishSyntax />
.
I think plain JS should use plain .js
extension.
$ npm install
...
npm ERR! [email protected] install: `node install.js`
npm ERR! Exit status 1
npm ERR!
npm ERR! Failed at the [email protected] install script 'node install.js'.
npm ERR! Make sure you have the latest version of node.js and npm installed.
npm ERR! If you do, this is most likely a problem with the phantomjs2-ext package,
npm ERR! not with npm itself.
npm ERR! Tell the author that this fails on your system:
npm ERR! node install.js
npm ERR! You can get information on how to open an issue for this project with:
npm ERR! npm bugs phantomjs2-ext
npm ERR! Or if that isn't available, you can get their info via:
npm ERR! npm owner ls phantomjs2-ext
npm ERR! There is likely additional logging output above.
$ node --version
v6.0.0
What we’re using phantomjs2 for?
Having a feature to run a program on PC without any Arduino opens XOD to people who don’t yet have a board, for very quick experiments, and quicker development.
system-time
linked to watch
WasmSerial
object which mimics the standard Serial
print/write/flush operationsXOD_DEBUG_SERIAL
as WasmSerial
in case of simulation and basic DEBUG_SERIAL
otherwise. Use the XOD_DEBUG_SERIAL
in the watch
implementationThere should be help available for nodes available on node choice stage as well as when a node already placed.
Node’s help page should contain an overall description, each pin type info and description, pre-render of the node. The info should be fetched from node metadata.
See vvvv help pages for inspiration.
The story is a prerequisite to a very important #31. Although it is self-sufficient.
We should create a project browser sidebar where the user can add, modify, delete, navigate through several patches of his project.
Any project starts with a single patch named main
. But the user can rename it and add more patches. Patches are equal in rights, they kinda “simultaneous”. So there is no actual main one.
Story acceptance criteria
We should have an intuitive cut/copy/paste behavior like most editors do.
Don’t fake clipboard contents, use implemented functionality to forge the data required.
Don’t involve real clipboard of the OS in tests.
As a documentation author, I want a command-line utility that given a path to patch JSON would provide rendered SVG file.
Patch figures are massively used for end-user documentation. It’s a pain to have a long toolset to produce that images.
The better idea is to keep example mini-patches as JSONs along with documentation source files and get them rendered automatically on documentation build.
This would also guarantee that we’ll get 1:1 visual experience between IDE and HTML docs.
Produced SVG’s must be correctly rendered by supported browsers.
xodc render /path/to/project/patch-to-render/patch.xodp
and result SVG well be rendered to stdoutxodc render
can understand paths of shorter form /path/to/project/patch-to-render/
and /path/to/project/patch-to-render
as wellxodc render
can take --output
or -o
argument to output to file rather than stdoutxod-client
that would produce a single CSS for patch renderingReadOnlyPatch
React container that is similar to existing Patch
but doesn’t attach all interactive stuffrender
subcommand use that container and invoke method to render it to an SVG stringImplement serializer classes.
For a beginning just Serializer (abstract) and LocalStorageSerializer.
Serializer works only with Services and works with serverState (composition of all service states).
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google ❤️ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.