> "ComputeOpticalFlowBetweenTheseTwoInputImages", how is that any different from calling the ComputeOpticalFlowBetweenTheseTwoInputImages function in the underlying algorithmic engine
There can be a ton of difference, at least in the theoretical possibility space. But the tools, especially free, open ones have not matured enough to show the difference yet.
To begin with, on a text based environment you may need to look up the library's documentation to figure out the available operations within that. A visual environment can visually show you all the operations. You can say that there are certain environments and editors that can provide autocompletion, especially static typed languages, but there are several limitations even in that: First, the autocompletions almost always doesn't have much context built into them, so they will keep showing the same completions on several contexts and can be overwhelming. So the user need to go back to the documentation to figure out the available operations in that context. A smart, environment (can be either visual or text) can show completions for that context alone. Second, there can be many reactive parameters on a function call, especially if the parameters are long or complex objects that requires extensive studying of the underlying documentation. For e.g., if you are changing a parameter, another parameter's value might depend on what you have given in the previous parameter. A properly constructed visual interface can show and hide or change the structure of the parameters based on the rules and can replace the documentation if properly created, saving the users from frequently referring documentation or causing unnecessary compile and runtime errors. You might think it's a small thing, but if you look closely, this is where most of the time a developer spends, apart from figuring out the sequence of operations to perform. Now a text based environment can do most of these "smart" things, except for showing the sequence flow.
Now for the sequence of operations, a visual or data flow language, if properly implemented can arguably be better than text, because A) It can automatically show the available operations depending on the sequence (or the context). B) More importantly, it can show the big picture at a glance with the visual connections between the sequences. This can be a life changer, especially during debugging and when you have large number of programs or files.
Now in my experience there are no proper visual implementations in public domain that successfully done both A and B, that is reducing the general public's confidence in such a platform. But a proper implementation can make the life of developers significantly better, except a catch - whether the developers need it or not. It's like, It's almost like asking a truck driver, whether he wants an AI assistant or not and he somehow gets that while it makes his life easier but also significantly lower the barrier of entry for truck driving skill :)
ps: I am building a visual environment that can hopefully meet many of things said above..
edit: fixed few typos and added a disclaimer.