
What Programmers Can Learn from Modular Synthesis and Unix - NoraCodes
https://nora.codes/post/modular-synthesis-and-unix/
======
csb6
This is a unique way to think about it. My issue with the Unix way of doings
things, though, is the user unfriendliness/large amount of weirdly-named
commands/syntax and one letter flags that make reading other people’s code
hard. It doesn’t help that shell script syntax is also finicky/strange
compared to other programming languages. With physical things like
synthesizers, you can reason about things spatially/physically, understanding
each component in a way that is hard to do with unix programs with dozens of
flags and slight incompatibilities between platforms.

Still, Unix is good. I just wish there was a system that provided this kind of
modular toolkit for software in an easy to pick up format without worrying
about backwards compatibility with generations of Unix systems and the quirks
of those past systems, hard to describe environments, and scattered config
files/complex build processes. I think some form of a standard structured data
format and some kind of type-checking at an OS level would be neat, too.

~~~
cue_the_strings
Powershell, for example, tries to address these points by naming commands more
verbosely, having verbose flags and even having programs input and output
object-y data instead of just plain text.

These are all nice ideas that don't work very well in practice because the
verbosity is only beneficial when writing scripts and is just cumbersome for
interactive use. Also, Linux (and other Unix-likes in general) are better
designed to be used w/ scripted and cli tools, and the object nature of IO
often just gets in the way. But the biggest issue is that the built-in tools
just arent as powerful as POSIX core utilities and especially GNU-extended
ones.

~~~
csb6
> These are all nice ideas that don't work very well in practice

Yeah I agree with what you said about Powershell, but I think there is a
balance. Some Unix programs have the ‘—-‘ style verbose flags, which is good.
However, I would argue that the overall Unix-like environment fails all the
time and causes massive, needless headaches, not just because of syntax/flag
name lengths, but because libraries and config files are stored all over the
place, depending on implicit features of the environment. I guess my main
point is that Unix is like death by one thousand cuts; it is
modular/composable/flexible, but in an extremely haphazard and janky way that
makes developing in it painful in ways it doesn’t have to be. We haven’t
really seen the ideas I was talking about in practice (e.g. optional
typechecking between programs), so it’s not really clear how they’d end up
working out. But there has to be a better way than the Unix way (as it is
right now).

------
wallflower
And to complete the circle, newer Moogs are full blown, hackable Linux-powered
analog synths.

