
Dijkstra on Dutch TV (2000) - edejong
https://www.youtube.com/watch?v=RCCigccBzIU
======
computer
At 12:14 the original Dutch on-screen text says

>"We should not add bugs to a program out of nonchalance. We should do so
systematically and with great care".

The translator translates this to

> "We should not introduce errors through sloppiness, but systematically keep
> them out",

which I found unfortunate, since it completely loses the original meaning.

------
justin66
No acknowledgement that the other side of the tradeoff might have some great
merit in the software correctness argument, even when discussing
accomplishments as great as putting a guy on the moon on a tight schedule. And
throw in there something about pretending not to understand what "lines of
code" means.

Dijkstra doesn't disappoint in this interview.

~~~
andreasvc
I don't think he meant to say it is unclear what 'line of code' stands for,
but rather the correct observation that it may mean very different things
depending on the programming language involved, and the problem being solved.

What is this "other side of the tradeoff" you speak of? Should there have been
such a tight schedule in putting a man on the moon? I think you might have an
argument about software development in general, where the standards do not
need to be this high all the time, but in the case of the moon landing it's
hard to argue for loose standards when human lives are at stake. It's rather
disconcerting they admit they just got lucky, in terms of software
correctness.

~~~
gw
There is always a tradeoff, even for projects where lives are at stake. We do
not have infinite time or resources. Nobody but you used the term "loose
standards"; the argument is that all projects involve a tradeoff between speed
and correctness, even when some demand more of the latter and less of the
former.

~~~
dkarapetyan
That's the standard narrative and parroting it over and over again doesn't
really make it true. Arguments over correctness almost always devolve into a
shouting match because no one ever defines what they mean by it. For your
standard consumer application a notion of correctness doesn't even exist so
the argument is moot there. You have to narrow your domain a little bit to
actually start talking about it. You have to get down to the level of
protocols and interfaces and other mathematical beasts where correctness
actually means something.

The standard example of correct software and in fact where most work on formal
correctness tends to happen is in compiler design and distributed systems. So
when you say that there is a tradeoff between speed and correctness that is
simply not true. All those compilers you use are correct, for a very precise
definition of correct, and fast and constantly improving.

~~~
icebraining
_All those compilers you use are correct, for a very precise definition of
correct_

Are they? How do we know? And if they are, why is GCC's list of major and
critical bugs[1], for example, longer than a laundry list?

[1]
[https://gcc.gnu.org/bugzilla/buglist.cgi?bug_severity=critic...](https://gcc.gnu.org/bugzilla/buglist.cgi?bug_severity=critical&bug_severity=major)

~~~
dkarapetyan

        Beware of bugs in the above code; I have only proved it correct, not tried it. 
        - Donald Knuth
    

Formal correctness and implementation correctness are still separate issues in
compilers like gcc but that doesn't change the fact that there are correctness
specifications for gcc. There are projects that try to bridge the gap:
[https://en.wikipedia.org/wiki/CompCert](https://en.wikipedia.org/wiki/CompCert).

------
wyager
I've read a few of Dijkstra's EWDs, and his letter to the UT Budget Council
re. their decision to switch from Haskell to Java for freshman programming. He
always came across as someone who wrote with a very high signal/noise ratio.

Turns out even his speech was like that as well! I was eagerly absorbing every
word.

------
jacquesm
The transcriptions of a lot of those EWDs are here:

[https://www.cs.utexas.edu/users/EWD/transcriptions/transcrip...](https://www.cs.utexas.edu/users/EWD/transcriptions/transcriptions.html)

------
NicoJuicy
If anyone speaks dutch here, you should view the Video reports that Tweakers
did some time ago about Dutch people in US. For ex. About Java founder Arthur
van Hoff [http://goo.gl/qlEPYX](http://goo.gl/qlEPYX)

And many others (you can find the other ones in the right sidebar with :
"Gerelateerde inhoud")

It's actually a very interesting video-series about designers at Apple or UX
experts at Adobe for example. And more importantly, how they got there.

------
krmtl
Using a pen instead of a word processor may adapt our mind to "getting it
right the first time". We might need word processors that limits editing?

~~~
garretraziel
I completely agree, but is "getting it rigt the first time" really THAT
important?

