[TUHS] unix "awesome list"

Steve Johnson scj at yaccman.com
Wed May 9 01:31:43 AEST 2018

Well, as I look to the future I see the whole approach we have to
software running into a dead end.  In fact, I think software is
holding us back.   It wasn't always true.  In the old days,
software ideas (like floating point, index registers, caches, etc.)
proved their worth and were put into hardware to make them faster.  I
think around 1980 this stopped happening.  Instead, hardware gave us
20 years of Moore's law, with ever faster and cheaper processors. 
 The increase in performance pretty much hid the inefficiency that
the software bloat introduced.

Starting about 2000, this changed.  Hardware was no longer offering
increased speed.  But what it was offering was massive parallelism. 
The response was to cling to the one instruction at a time model,
introducing multicore and its attendant hardware complexity to try to
cling to the previous model of programming.   The hardware to make
this possible is expensive and does not scale.

My company, Wave Computing, has built a chip with 16,000 8-bit
processors on it.  And we have plans to build systems with up to a
quarter million processors.  We are breaking ground in new ways to
use hundreds of processors to solve problems very quickly.  It's a
new way of thinking, and it makes your brain hurt.  But is is what
the hardware is giving us, and there is at least another order of
magnitude ahead before this trend starts running out of steam.

And it's exciting...


----- Original Message -----
 "Clem Cole" <clemc at ccc.com>

"Bakul Shah" <bakul at bitblocks.com>
"The Eunuchs Hysterical Society" <tuhs at tuhs.org>
Tue, 8 May 2018 10:53:16 -0400
Re: [TUHS] unix "awesome list"

I'll take a slight different road on this topic.  I think we are
dealing with the paradox of progress.
 I don't blame Linux's developers any more than I blame BSDs or
anyone else.   Really it was hardware progress/Moore's law that
changed the rules :-)

As much as I wax a bit for the simplicity of the Fifth, Sixth, and
Seventh Editions of my youth, the truth is I would not want to try to
use them today.   My needs are now different and I think the is true
for most people also which is why a modern UNIX implementation is
different from the original ideas or maybe I should say ideal.  That
said, a lot of what I did then, ands like Steve, I still do use and
many of the 'classic solutions' I find are better for me (_i.e. _troff
_vs._ MS-Word)

Pike's '_cat -v harmfu_l' paper foretold where we would get.   On
the PDP-11 with a limited address, a programmer was constrained so you
had to keep things simple.   The programming model of small simple
programs that did one thing well, was easier to 'enforce.'   The
ideas that formed UNIX make sense, and yoiu could build an extremely
power 'system' from simple and small things.   At the time, that was
almost heretical.    But once HW dropped in price and the address
space issues relaxed the size of a program that could be written,
people did.  The cast was out of the bag, and there was no going
back.    I'm not saying all of the new BSDism of the time were
right, but they certainly made many things easier/more approachable
for many users and many/most live in modern UNIX definition.

I think Ted makes an excellent point, that *BSD and Linux, by their
nature of being 'open' and 'available' pushed the code along and that
needs to continue to be the high order bit.  Open and freely
available had a huge positive effect, because many of these new
feature (like X-Windows, Networking) were 'useful' and the cost to add
them was accessible -- so people added them.   But .... slowly the
system changed and the _expectations_ of the users with them.

I admit, I'm torn.   I do think Pike was right and many of the new
features/frameworks _et al_ are pretty lame (useless IMHO) and the
simpler/cleaner methods of old, are being ignored. Dave Pressotto and
I were talking a week or so ago and Dave made the observation that
he's not sure he knows how write a modern program now with all these
frameworks, IDEs, _etc_ and I completely agree.  But that is the old
guy in me talking; but I really do want to see progress and the new
generation make its mark.  I'm sure they will do wonderful things. 

Bakul's observation of little >>practical<< progress is an interesting
one.   In many ways I agree, in others I'm not so sure.  I think
Ted knows that my major gripe with some of the Linux (and Gnu style)
community has been a focus on reimplementing things that were already
there instead of using what could have been taken from somewhere else
such as BSD, or replacing subsystems just because they could without
really adding anything (_i.e._ the whole systemd argument).

But over all, as much as I respect and think Ken and Dennis did
amazing work at the time, I do tend to love when new ideas/things have
been done beyond the original ideas from Ken and Dennis.  For
instance, just as BSD can take credit (or blame) or sockets and making
UNIX really a 'networked OS', Sun really gave us multiple file systems
with the VFS, but  I strongly credit Linux for really making kernel
modules a reality (yup Solaris had them, as did a few other systems -
but it was really Linux that made it wide spread).   I wish Linux
had taken the idea of a modular kernel a tad farther, and picked up
things like Locus vproc work, because I personally think modularity
under the covers is better than the containers mess we have today (and
I agree with Tannenbaum that uKernel's make more sense to me in the
long run - even if they do cost something in speed).

it's also why I liked Plan 9 and have high hopes that a new OS, maybe
written is something like Rust might finally appear.   But I don't
want it re-implement UNIX or Linux.   Grab from them the subsystems
that you need to duplication, but don't re-invent.

Warren - at the risk of being political -- I think the paradox we have
it larger than just UNIX, although it is simple.  We can wallow and
say everything is bad, it was simpler in 1959 -- which exactly what
some folks in my country seem to be doing in other areas.  I
personally can say my world was simple in those days and I certainly
have fond memories [read Bill Bryson's
[1] which parrots many of my own memories of those times ], but UNIX,
like the world, has grown up and changed and is a lot more
complicated.   I like progress we have now.  I don't want the world
the way it was any more than I want run Fifth Edition on my Mac for
day-2-day work.

Yes, I would like us to look at the good from the past and see if we
can have some of the good things again; but if it means giving up what
gained too, then we have gone backwards.  The problem is how to
decide what was good and what was bad?   What is real progress and
what is just 'showing off your money' to use a Forest Gump concept.

I suspect we will argue for a long time about what qualifies as
progress from the core idea of UNIX and what does not.




-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180508/a6959a50/attachment.html>

More information about the TUHS mailing list