6 Jul
2018
6 Jul
'18
5:11 a.m.
On Thu, 05 Jul 2018 13:49:58 -0700 "Steve Johnson" <scj(a)yaccman.com>
wrote:
That's an interesting topic, but it also gets my
mind thinking about UNIX
features that were wonderful but didn't evolve as computers did.
My two examples of this are editor scripts and shell scripts. In the day, I
would write at least one shell script and several editor scripts a day. Most
of them were 2-4 lines long and used once. But they allowed operations to be
done on multiple files quite quickly and safely.
With the advent of glass teletypes, shell scripts simply evaporated -- there
was no equivalent. (yes, there were programs like sed, but it wasn't the
same...). Changing, e.g., a function name oin 10 files got a lot more tedious.
With the advent of drag and drop and visual interfaces, shell scripts
evaporated as well. Once again, doing something on 10 files got harder than
before. I still use a lot of shell scripts, but mostly don't write them from
scratch any more.
With specialized apps there is less need for the kind of
things we used to do. While some of us want lego technic,
most people simply want preconstructed toys to play with.
What abstraction mechanisms might we add back to Unix
to fill these gaps?
One way to interpret your question is can we build
*composable* GUI elements? In specialized application there
are GUI based systems that work. e.g. schematic capture,
layout, control system design, sound etc. (Though for circuit
design HDL is probably far more popular now. Schematic entry
is only for board level design.)
Even if you designed GUI elements for filters etc. where you
can drag and drop files on an input port and attach output to
some other input port, the challenge is in how to make it easy
to use. Normally this would be unwieldy to use. Unless
you used virtaul "NFC" -- where bringing two processing blocks
near each other automatically connected their input/output
ports. Or you can open a "procesing" window where you can type
in your script but it is run until its output is connected
somewhere. Or an "selection" window where copies of file/dir
can be dragged and dropped.
This may actually work well for distributed sytems, which are
basically dataflow machines. [Note that control systems are
essentially dataflow systems.] This would actually complement
something I have been thinking of for constructing/managing
dist.systems.
Note that there are languages like Scratch & Blockly for kids
for programming but to my knowledge nothing at the macro
level, where the building blocks are files/dirs/machines, tcp
connections and programs).