Shameless Self-promotion Sunday #18
Here's a pretty old post from the blog archives of Geekery Today; it was written about 16 years ago, in 2008, on the World Wide Web.
Everyone wish L. a happy birthday!
Then, since it’s Sunday, let me know what you all wrote about this week–leave a link and a short description for your post in the comments.
Follow
Happy birthday, L! (who’s L?)
For the week: I attempted to cast my quest to renounce my American citizenship http://www.nostate.com/504/renunciation-as-divorce/, and then had a wee bit of fun writing a ridiculous http://www.nostate.com/514/and-you-agree/ as a means of exploring (for myself, largely) the concept of unalienable rights.
Nuts, total screwup on my links. Should be:
as a divorce
and
website access agreement
sorry!
Happy birthday L.!
( :
Hi Rad Geek,
I asked some questions about epistemology at philosophypathways.com, but didn’t like the answers I got. Since you do both web design AND philosophy, I’d like to hear what you think. To find my original questions, do a ctrl-f for my name on this page:
http://www.pathways.plus.com/questions/answers.html
(Incidentally along the way I found your posts on the Gettier problem which were very interesting!)
My questions were 1) Why are humans fallible and would any finite being be fallible and 2) in computer programming why are people so confident that meticulous design will make a program “just work” when in fact a debugging, trial-and-error approach is far superior?
To my chagrin the response to my first question was “what does fallible mean?”, and the response to my second question was to deny its premise! Let me explain the second question more precisely: I have noticed that in many programming courses and books people seem to have this idea that if you work hard at making a good design for a program and meticulously carry it out then there will not be bugs and the program will “just work”. (Usually such books, if they discuss debuggers and the like at all, relegate it to a chapter in the back or an appendix.) This is totally backwards! When I write a program to do some task in C for example I spend 20 minutes writing it and then an hour with the debugger fixing bugs! (In fact often I don’t even try to run the program the first time it compiles, I just immediately load it into the debugger!) In Java or Python or Perl if I have to make a large program the test cases are the first thing I write! This idea that programming is 90% careful crafting and then 10% tidying-up at the end seems completely crazy. For an analogy, consider the task of adding up 1000 numbers. Most people will have trouble getting the right answer every single time. In fact, as one of the respondents on that webpage suggested, it would be nutty to do a meticulous, careful analysis of each step looking for any possible error. Instead, it would be much more economical to just add up the numbers several times and then take the most common answer as the correct one (sort of a statistical approach really).
My original question concerned why people erroneously prefer the “meticulous design” method, not whether it was in fact the better method of the two. So I’ll split the question up thusly: 2a) Is meticulous crafting really preferable to trial-and-error, “statistical” reasoning for large tasks like adding up a 1000 numbers or making a program to do a company’s accounting? And 2b) If not, why do people seem to often believe it is?
Unfortunately there’s scant room to discuss the Gettier problem because of all the space I had to devote to explaining this one. :(
Happy birthday, L!
I recently did a post on draft registration and the “national service” schemes that are now being advocated a lot.
I did a brief blurb on Team ObaMcCain’s nauseating commonality re: “national service.”
And a very happy birthday to L. (Whom, I assume, is RadGeek’s significant other, yes?)
For the purposes of this blog, L. =df Laura, my beloved wife and sometime co-conspirator
Gabriel,
On fallibility, I think that your friend was mistaken about Plato. He certainly doesn’t oppose the view that human beings can make mistakes; in fact, in his view (at least, as apparently expressed through the character of Socrates in the Republic) is that the vast majority of our everyday, commonsense beliefs are to some extent illusory, mistaken, or false. (Sometimes because we have beliefs that are just flatly wrong, as when someone ignorantly believes that the world is flat rather than round; but even when everyday beliefs are not mistaken in the same way, Plato’s Socrates thinks that most people misunderstand their significance and fail to grasp important things about how they are related to each other. He compares the vast bulk of our everyday beliefs to the flickering shadows of false images of real things, presented to people imprisoned in a cave and as yet knowing nothing of the real world outside. On his view this often leads to other kinds of mistakes, especially philosophical confusions — such as the metaphysical mistake of mistaking sensible reality for the only aspect of reality that there is — or for hastily treating easily understood material or psychological benefits — like wealth, honors, or pleasure — as the only kinds of things really worth having.) What your friend seems to have been thinking of is the earlier Socratic view (defended in earlier Platonic dialogues, but abandoned or at least substantially modified by the time of the Republic) that people only make intellectual and moral mistakes from ignorance, not from knowingly doing the wrong thing. (He uses the term to include not only factual ignorance but also philosophical confusion, and ignorance about what kinds of things are good.) Ignorance is a bad state to be in, so it’s not that he’s denying that people are fallible; he’s just trying to give you reasons to recategorize the kind of failure that’s involved, and thus also to reconsider how you react to people that are making that kind of error. (For example, he thinks that the unjust deserve your pity rather than your envy.)
Which leads me to what may be a frustrating answer to your broader question about fallibility — to some extent I agree with your first interlocutor that a useful answer will probably require a more precise question. There are lots of things which come under the heading of “mistakes” and “fallibility,” and lots of different kinds of failure — there are slips, and mistakes and errors; there is plain ignorance, willful ignorance, confusion, carelessness, stupidity, hastiness, foolishness, madness, inattention, one-sidedness, intellectual vice, moral vice, etc. etc. etc. Many of these overlap and all of them interact. Some of these merit blame and others don’t; some of those that merit blame are excusable and others aren’t; some are easily corrected and others are not; some are easily avoided and others are not; some are more or less inevitable in beings constituted as we are while others are avoidable but very likely to come up at some time or another in everyday life; others are avoidable but their likelihood depends on the person; others are very unusual.
(For example, plain ignorance is no doubt an inevitable part of the human condition. We are born knowing nothing and it takes many years of effort even to be able to understand what certain disciplines are about, let alone to know the things that there are to know about them. I suppose that’s related in some sense to our — in the sense that we begin our lives at some particular point in time, and have no instantaneous or automatic methods to acquire the knowledge that we might need. Occasional stupidity, slips, intellectual one-sidedness, etc. are not inevitable, but it’s hard to go through life without ever committing them, and given the amount of care and worry that would be needed to avoid them all, individual cases are often excusable and just something people have to deal with. Often it’s more important to make sure that you deal responsibly with these kind of mistakes when they do happen than that you try to prevent them ever from happening. More nasty forms of error — like willful ignorance, bullshitting, inhumanity, shamelessness, intellectual dishonesty, etc. — are another matter. These are certainly not inevitable, and there’s no reason to believe that they have to be as common as they are. People can and should put as much effort as they need to in order to change their lives, to change their relationships with other people, to change the institutions with which they have to deal, etc. etc. etc. in order to make these forms of inexcusable vice less common, to make them easier to avoid, to make them seem less attractive than they often seem to the people who indulge in them, etc. etc. etc.)
I don’t know how far all this helps clarify things, and how far it distracts from what you were interested in discussing. Let me know what you think.
As for programming, debugging, and the method, I think you’re largely right, and that you’re on to something interesting. Part of the difficulty may be that it is just difficult to teach people how to do debugging and how to deal with errors — or, at least, computer scientists haven’t put nearly as much thought into it as they have put into how to teach topics like programming languages, data structures, and in general how to do things right. (This is often a problem when education goes wrong: that people are spending all their time teaching the things that they know pretty well how to teach in a conventional classroom format, but neglecting some of the most important things, not because student’s shouldn’t know about it, but rather because it’s hard to figure out how to lay the subject out.) Perhaps if more people thought about the problem of how to teach people how to detect and adapt to things going wrong, it would become easier to teach; at the very least, there might be more textbooks to use. Certainly I would have benefited from more systematic discussion of debugging and unit testing when I was taking CS courses.
On the other hand, I also think that your interlocutor is right about some other, related topics. For example, that the source of many errors in programs are institutional as much as they are the result of individual programmer error; and also that individual programmer error is often partly a function of bad supporting tools. (The popular programming languages that we have today are a case in point; they tend to be very poor about providing tools that could easily be provided, which would prevent a great deal of programmer error from happening in the first place.)
This wasn’t by me, but I wanted to shamelessly promote my website. My blagmate Kel responded to a pro-voting column in our alma mater’s pathetic student newspaper with his own explanation of why he doesn’t vote.
He then got it published in said student newspaper, with hilarious discussion-thread results (hilarious in a sad, depressing way).