As for Luna, it seems like they've gone quiet for the past while, though I believe they're still hard at work on the project. Hopefully they can improve the stability and performance of the program, because to date I've found it almost unusable.
For a similarly interesting project (albeit not visual in the same way), I recommend people also take a look a isomorƒ: https://isomorf.io
My favourite is the "Gallery of Programmer Interfaces" by Jonathan Edwards: https://docs.google.com/presentation/d/1MD-CgzODFWzdpnYXr8bE...
I can also heartily recommend following Edwards on Twitter: https://twitter.com/jonathoda
Max and Pd are included in “Implementations” because you can use them to do general purpose programming — they just excel at audio thanks to a great standard library.
Also Substance Designer and Nuke.
Unlike Luna though, my own environment does not have a dual-syntax representation. It can import functions from TypeScript though and export them as nodes. I also plan to target build tools rather than data processing.
I'm excited to see so much progress being made in this area. Two other examples are NoFlo (https://noflojs.org/) and Flolab (http://flowlab.io/).
(We also do visual programming, though for algo trading.)
What has your experience with Xod been like? Have any advice?
However, LabVIEW is one of the oldest visual dataflow languages (AFAIK only Prograph is older), and it's certainly worth learning about if you're interested in visual and dataflow programming.
would you mind elaborating? i would be interested to see what you mean. if you are thinking of more functional ways like maps, filters, folds, and the like, i have done that in labview. there is limited support though since labview doesn't have lambdas, but you can pass around functions. however, that being said, i don't really see a problem with the for and while loops in labview, and i can't see how they are overly complex. they are about as simple as it gets. condition structures could be improved, but i also don't quite see a vastly different way to do it but rather tweaks that could be made.
> Also, type inference is actually simpler to implement in visual dataflow than it is in text-based languages, yet LabVIEW lacks it
i am not for sure what you mean here by saying labview doesn't have type inference. labview is constantly running a type propagation algorithm that checks whether all the types are hooked up correctly. additionally, labview has malleable VIs, which is even more advanced. you can develop functions that are polymorphic across types. you could do this before malleable VIs using polymorphic VIs, but you had to manually create them. now, when wiring a type to a malleable VI, labview will dynamically (at edit time) adapt the malleable VI's types, primitives, and subVIs to adopt the new type. if it can't, it will warn you. you can also wrap code with a type structure such that different code is tried depending upon the type. again, it will check if a wired up type has a given structure case that fits. it is similar to pattern matching on types.
> Finally, every dataflow program is a directed graph, which is the most general data structure there is, so it really ought to be a fundamental data type - like Lisp's S-expressions are.
i agree that there should be a more fundamental type. i am not aware of any language that does so, and even in the text-based world, lisp and scheme stand alone in this feature (not surprising i like those languages as well).
My own dataflow language is described here: http://www.fmjlang.co.uk/fmj/tutorials/TOC.html
The pages are incomplete as I've since added new functionality to the language. I'm working alone, and have other commitments, so progress is quite slow. It's a research project, and I'm not planning any release until I'm happy with the language, and enough other people are sufficiently interested.
For iteration and conditional statements, FMJ doesn't require any separate constructs or use syntactic sugar. Iteration is done by feedback, when and unless by conditionally outputting other inputs depending on the value of the first input.
My aim was to build a language capable of running directly on hypothetical dataflow hardware, with the minimum of syntactic sugar, and I've mostly achieved that. I'm now looking at problems for which dataflow machines would be better suited for than conventional hardware, and by implication that dataflow languages are better suited for than conventional languages. I'm also looking for ways of reducing clutter (edges crossing), which is a problem with graphical languages.
Regarding directed graphs as a fundamental data type, I haven't done much in that regard yet, but it's high on my list of priorities.
that is more that most people who program it don't put in the time or effort to program it in a professional way. personally, i do and was trained by people who did and do, and so i have seriously complex systems built out of it that are far more maintainable than other people's systems built out of python and c/c++, which are the unfortunately choices for system development where i have worked.
the point is, just like with any language, you have to settle on the (or an) idiomatic way of working in the language, and you have to be disciplined to develop modular, decoupled code. once you do so, i find that labview's dataflow paradigm actually makes it easier than most languages to develop dependable, robust, and maintainable code. the reasons that people like functional programming languages with immutability apply to labview.
people writing unmaintainable software in labview is a symptom of the people and not the language. every time labview is brought up in meetings as the target language, there is often a gut reaction by people, but to be frank, those people actually know very little of the labview language, have never used its OOP features, are not even aware of its debugging capabilities and tools, and thus, their opinion is moot. just because someone used labview in college in a trivial way but didn't like it doesn't give them a professional voice with regard to labview. all they usually want to do is develop unreliable systems using c/c++ or python because that's the "hardcore" way of doing things. and yet, it's those projects that are often pining for help in the end when things aren't working.
so yes, labview is different, but if you treat it differently, it can greatly increase your efficiency and ability to quickly turn around robust systems. i develop systems in time units of months, not years, and my software is well known to just work.
what would you say the "confusing syntax" is that leads to unmaintainable software?
Most of my contact with LabView code was built by people that had no professional training on it. They use it to automate "simple" scientific experiments and create visualization dashboard, since they're mostly self-taught their software needs a re-write every 3 years.
Again I believe you are right, that is mostly due to the programmer not being knowledgeable about the language itself.
Regarding the syntax, most of the LabView code I've seen was built by people with the aforementioned knowledge of the language, so It is possible that I've never seen good LabView code. But I never liked the looping and conditionals.
LabVIEW is limited to the research and academic realms AFAIK.
Currently I'm working on a data science tool called ohayo (https://github.com/breck7/ohayo) that combines text coding with visual programming. It's geared toward similar use cases as RStudio, JupyterLab, Tableau or Observable, but takes a different approach.
At a higher level I'm working on Tree Notation: http://treenotation.org/. My not-at-all-humble contention is that this syntax is a breakthrough that will allow visual programming to become commonplace generally (it already is in some fields with tools like labview/excel/unity/tableau/etc) , because with it you can create programming languages that have the property that the code written by humans or machines(visual tools) is the same. Hence, whether you write the code by hand or use the visual tool, you'll still have great, clean code. With current EBNF languages or XML/JSON/etc languages the interaction between humans and machines is a mess.
For a decade I've also researched programming languages extensively and have a ton of data on over 10k languages at this point.
Is that something you're handling in your project? Do you have any pointers?
However, I don’t support generics as first class citizens in the node editor yet and probably won’t for V1. I can detect that an input/output is a generic but I convert it to any before use.
If your project is based on an existing language I’d recommend taking a look at injesting compiler tools if they are open source.
Luna looks great and I actually think I initially saw it and then I was looking for it but couldn't find it, ending up with Node-RED. I might give it a try, however I didn't see any mentions of how it integrates with Git :/
Like this: [https://nodered.org/docs/user-guide/projects/]
Many people swear by them.
I like that Luna has a text syntax.
I also like that Luna supports building graph functional blocks that can be nested inside other graphs. That's a missing link in other tools of this type that limits the scale of what you can do with them.
I'd like to see a tool like this which has something like a JSON document going over the lines, but that might be asking too much. If the objects going over the lines are basically relational rows you can do columnar execution at very high speed. The Actian people have looked at alternatives to what they do, but I think they haven't extended the data model past relational because they couldn't get it fast enough to compete with their own product.
(e.g. a classic "disruptive technology")
Spread sheet programs just have a bad rap of being used by non-programmers, and limited functionality outside of the spreadsheet universe. Ignoring the caveats mentioned, the principles of spreadsheet programming are programmatically sound. Spreadsheet programmers are functional programmers.
The trouble w/ spreadsheets I think is organizational. Some things are an exact match for the 2-d grid, other things (say you fill out 5 numeric fields and then calculate with scalar formulas to produce a similar dimensional output) are easy to express with it (even if tk/solver is a better fit.)
Then you rapidly go over a cliff where you don't have the organizational tools to handle it -- tuple and set values programming (eg. Matlab, Sql) is one answer, object oriented is another.
Functional programming does not progress in a particular direction either. What you describe is spread sheet programming, but it is also a description of functional programming.
>Then you rapidly go over a cliff where you don't have the organizational tools to handle it -- tuple and set values programming (eg. Matlab, Sql) is one answer, object oriented is another.
It's not so much organizational tools vs. a different style of thinking. OOP and sets can be used in both spreadsheets and functional programming (think: a spreadsheet column can be thought of as both a set or a object struct and thus both paradigms can be applied). Procedures and ordered steps cannot be used in functional programming nor spreadsheet programming, hence the term "procedural programming" which is what I think you are actually referring to in your last statement.
You lose many potential clients just for that alone
Is this true? This is not my strong domain but I'm sure there are such programming languages.
Edit: Gotta say, I love x3 the design/aesthetic/presentation of the Luna language.
The in-development GP language can alternate between blocks and text: https://en.scratch-wiki.info/wiki/GP_(programming_language)
It also depends what we consider human readable: Does it mean that some or many or most humans can read it? It's a custom plain text format that is perhaps a little bit less readable that HTML. I have been reading and writing Pd patches in textual representation (and I'm human). Not sure if that's an answer to the question.
I've seen a Scheme editor that does visual representation, slightly similar to Scratch, but can't remember the name of it.
AsciiDots is both visual and textual (although it's not two different syntaxes).
#N canvas 340 73 884 380 10;
#N canvas 0 0 1362 686 sendchord 0;
#X msg 241 135 60;
#X msg 240 167 64;
#X msg 241 200 67;
#X obj 191 173 bng 15 250 50 0 empty empty empty 17 7 0 10 -262144
#X obj 283 450 bng 15 250 50 0 empty empty empty 17 7 0 10 -262144
#N canvas 0 0 100 100 100 10;
#X obj 0 40 print;
#X msg 0 20 hello world;
#X obj 0 0 loadbang;
#X connect 1 0 0 0;
#X connect 2 0 1 0;
I think the readability of Pd is horrible, but the question was whether it was human readable at all.
This is the kind of visual programming I'd be ready to buy into.
Please, let's refrain from such awkward terminology. "Graphic language", "visual language" are fine. "WYSIWYG data processing" is okay. But let's not forget any graphic syntax is an abstraction.
WYSIWYG describes domain-specific tools that let you manipulate the final product directly (or a draft of it), without having to look at any kind of source, be it a node graph or source code.
Also, tutorials and examples are the Achilles' heels of GUIs. I remember back in the 1990s when you'd go to a bookstore and find 1200 page tomes full of screenshots that would tell you how to do everything in Word 95.
Something that is "just run this script" in a CLI is a 20-page checklist with screenshots with a GUI.
- visual and textual
- purely functional
I get the feeling that statebox might not be turing complete (guaranteed termination) and have a stronger focus on formal verification. Also, it doesn't seem to have a visual editor yet.
I know Statebox pretty well :)
Luna not super well, but I did beta test their first release (and some later versions), cool stuff.
Anyway, the two are (feature wise) very similar, as you noted:
- both have textual/visual representations,
- are typed FP languages,
- access to FFI/effects,
- diagram nesting
But Statebox is _not_ data-flow, it's more about "control flow" or "multi-party protocol execution".
(You could do data-flow with Statebox, but at the moment that's prohibitively inefficient.)
Where Statebox takes a different direction (I think) is in basing the language on established concepts from category theory and focussing on 'generality/compositionality' ; specifically, our diagrams are not "graphs", but (morphisms in) categories.
This difference is very very subtle, in fact, seems totally irrelevant if you want to visual programming (see the nice codex, clearly it works using graphs!)
but it becomes more important when you want to diagram's to be "universal". at least in principle, the Statebox language should naturally and compositionally translate to any kind of hardware ; we want you to be able to program smart contracts, p2p-systems, JS frontends, digital circuits, heck, maybe even slime molds, all from the same diagram.
Luna certainly has more features at this stage.
(also, our editor is under heavy development and not yet published, we are aiming to release some things around the statebox summit in september)
Maybe it's fair to say: Luna is like a better NodeRED, Statebox is conceptually closer to something like homotopy.io / globular.science ?
Hope this clears things up a bit
I think for the latter, it'll be really really difficult to achieve. I can maybe see the former, but I also worry for the former, these are too general, and domain specific graphical tools will always dominate.
still interesting, but i don't do much data science, so will probably never get a chance to use this.
As far as I remember the history correctly, Luna is a spin-off project from Flowbox development - https://flowbox.io/.
It's a fad that I wish would stop propagating.
Would be great to just hit "Enter sandbox" or "demo" or see a tutorial without the download.