[TUHS] Follow-on to the Pascal/C/etc. discussion
scj at yaccman.com
Mon Sep 4 08:53:36 AEST 2017
A great question, Jon.
Here are some things that I've stressed at times when teaching or
* Realize that programming is a service profession. A program's
users probably don't care what language it was written in or what
editor was used to write it or why it wouldn't run on their operating
system. They have a job to do. The challenge here is that
programming can be a lot of fun, so it can attract people who love the
act of programming and fill their programs with "neat hacks" that make
them feel good but do nothing for their users. This is the ethical
equivalent of waiters in a restaurant standing around joking and
flirting when you are hungry and want to order.
* Like music, programming often rewards people who get a bit obsessed
with it as youngsters and spend most of their time with it. This can
leave the programmers very short of basic social skills such as
writing and communicating with other team members and their users.
This opens the door to the worst kind of bugs -- not doing something
wrong, but doing the wrong thing.
* To oversimplify, every instruction in the computer either serves
the customer or the programmer. The customer may want to multiply
matrices. In their mind, the program is a triply nested loop with a
lot of multiplies and adds. Those instructions belong to the
customer. Instructions to set up call stacks, create and destroy
processes, do context switches, execute in device drivers, etc. etc.
belong to the programmers. The more you can attack and simplify this
kind of bureaucracy in the computer, the happier both you and the user
* If a program speeds up by a factor of 10, it becomes qualitatively
different. Or if it slows down by a factor of 10. Consider how
Google would feel if it took 5 seconds to respond instead of .5
seconds... Speed is important. In many cases that I've seen, slow
programs are slow because the "programmer's instructions" didn't
support well what the customer wanted to do...
* Interactive programs (Shell, Python, MATLAB, etc.) are great ways
to prototype. But beware of them as bases for production programs.
The problem is that bells and whistles can and do creep into the
language and be unnoticed because they happen within human reaction
time. At the keyboard, you don't notice, or may even like the
features, but when you are doing something a trillion times they can
cause the "programmer instructions" to dominate the run time. Also,
typos can lurk for years before detonating if you don't have a strong
typing and procedure definition environment.
Hope this was the kind of thing you were looking for...
----- Original Message -----
From: "Jon Steinhart" <jon at fourwinds.com>
To:"The Unix Heritage Society" <tuhs at tuhs.org>
Sent:Fri, 01 Sep 2017 16:29:22 -0700
Subject:[TUHS] Follow-on to the Pascal/C/etc. discussion
Hi everybody. I'm new to this list as a side-effect of my question
the provenance of strcmp and the convention of returning <0, 0, >0.
I had to learn Pascal as a freshman in college which was challenging
from BTL knowing C. Kept wondering how Pascal could be used for
useful. The answer that I later saw in industry was "by adding
Language discussions often turn to the issue of whether programming
should prevent programmers from making mistakes or whether that's the
the programmer. This is, of course, independent of discussing the
expressiveness of languages.
I agree that a lot of "programming" today consists of trusting and
together random library functions. That's not me; I often work on
critical devices and I'm not going to rely on libraries of unknown
when building a medical device that I make be hooked up to it
Years ago I inherited a project written in hodgepodge of programming
including ruby. My first reaction to ruby was "Wow, how do I get some
what they're smoking because it's better than anything I have?" I
asked Ward Cunningham about it because he was working for ruby house
at the time. His answer went something like this:
Jon, you're an engineer and you understand engineering.
You know programming and programmers and understand programming.
Then, there are the people with whom we entrust our confidential
credit card data.
That's what ruby is for.
This nicely summarized the current state of affairs in which the most
tasks are assigned to the least competent people. I see this as a
business, and political problem which can't be solved by different
I have often made the statement that "I would never hire someone who
had to use
glibc in order to implement a singly-linked list." I get push-back
such as "Oh,
and people can create bugs rather than using the debugged library?"
to which I
glibly respond "debugged library like OpenSSL?"
I am more than a little terrified by the "everybody must learn to
code in high
school movement". What they're learning is something at a level akin
ruby example above. The goal is clearly to make "coding" a minimum
and to many the distinction between "coding" and engineering is lost.
spoken with many kids in the "future engineer" category who are
the lack of depth in the curriculum. I'd summarize it as teaching
program without teaching them anything about computers.
Anyway, I have been volunteering to teach technology to kids for
karmic payback to my BTL explorer scout advisors Carl Christensen,
Lycklama, and Hans Lie. Not to mention all of the amazing people that
there when my dedication to hitchhiking up the the Labs after school
talking people into signing me in turned into a series of summer
I'm in the process of turning my class notes into a book. The goal of
book is to teach kids enough about computers that they can understand
their code is actually doing and why one can write better code with
understanding of the hardware and environment.
The book is in the editing phase so it's beyond wholesale changes.
curious as to what you all think should be in such a book as I'll
find a way
to wedge in anything important that I missed.
-------------- next part --------------
An HTML attachment was scrubbed...
More information about the TUHS