"A designer achieves perfection when nothing is left to remove." —Saint-Exupéry

The codenode blog is moving

without comments

Now that Test Noir has launched, it’s time for codenode to morph into an info site for codenode LLC, the parent financial company of Test Noir.  So this blog will probably move to  Also, this will give me something to point people at who ask to buy (it’s not for sale).

Written by Daniel Nichter

October 24th, 2012 at 12:13 pm

Posted in Announcement

Tagged with

Integrating Spam Free WordPress plugin and Journalist theme

without comments

Follow these steps to integrate the Spam Free WordPress plugin with the Journalist WordPress theme so that the plugin uses the theme’s style.

First, install the Spam Free WordPress plugin via WordPress.  It should activate automatically, but it won’t work at this point because (which you can see from the fact that there’s no “Copy this password” field for comments).

Next, in WordPress edit comments.php (Appearance > Editor > Comments), and add the bold line:

<label for=”url”><small>Website</small></label></p>
<?php if( function_exists( ‘tl_spam_free_wordpress_comments_form’ ) ) { tl_spam_free_wordpress_comments_form(); } ?>
<?php endif; ?>

If your comments.php has not been modified, then there will be a blank line between the first and third line, so you add in that space the bold line which calls the function that does the magic for the plugin.

Since the plugin adds two more fields, the tab indexes need to be updated.  Below the line you just added, you should see two lines:

<p><textarea name=”comment” id=”comment” cols=”100%” rows=”10″ tabindex=”4“></textarea></p>
<p><input class=”submit” name=”submit” type=”submit” id=”submit” tabindex=”5” value=”Submit Comment” title=”Please review your comment before submitting” />

Change those tabindex values from 4 to 6 and 5 to 7.

Save comments.php by clicking the “Upload File” button.

At this point, the comment fields should look like this:

Notice that the plugin’s two extra fields at bottom do not look like the three Journalist theme fields at top.  To fix this, click Plugins > Editor.  Select the plugin from the drop down list in the upper-right corner of WordPress.  It should default to editing spam-free-wordpress/tl-spam-free-wordpress.php.  In this file, look for:

// Reader must enter this password manually on the comment form
echo “<p>* Copy this password:
<input type=’text’ value=’”.$sfw_comment_form_password_var.”‘ onclick=’’ size=’”.$sfw_pw_field_size.”‘ /></p>”;
echo “<p>* Type or paste password here:
<input type=’text’ name=’passthis’ id=’passthis’ value=’”.$comment_passthis.”‘ size=’”.$sfw_pw_field_size.”‘ tabindex=’”.$sfw_tab_index.”‘ /></p>”;

Replace those lines with:

// Reader must enter this password manually on the comment form
echo “<p><input class=’comment’ type=’text’ value=’”.$sfw_comment_form_password_var.”‘ onclick=’’ size=’22′ tabindex=’4′ /><label for=’copypass’><small>Copy the password</small></lable></p>”;
echo “<p><input class=’comment’ type=’text’ name=’passthis’ id=’passthis’ value=’”.$comment_passthis.”‘ size=’22′ tabindex=’5′ /><label for=’pastepass’><small>Paste the password (required)</small></label></p>”;

Save the file by clicking the “Upload File” button.

Now the plugin should be working and in the Journalist theme style, like:

Optionally, in the same file, I like to replace this line:

wp_die( __(‘Error 1: Click back and type in the password.’, spam_counter()) );

with a more descriptive error message:

wp_die( __(‘Error: The required comment password is incorrect. Click back and copy-paste the password.’, spam_counter()) );

Finally, in Settings > Spam Free WordPress, you should either donate some money to Todd for writing this nice plugin or at the bottom set “Although PayPal donations are welcome, leaving this on is welcome compensation for this free plugin.” to On and save changes.

Written by Daniel Nichter

April 15th, 2012 at 2:49 pm

Free tickets to MySQL conference

without comments

Percona is giving away free tickets (and free books) to this year’s MySQL conference:

Written by Daniel Nichter

March 15th, 2012 at 8:38 am

Posted in Announcement

More software should JDTRT

without comments

More software should JDRT (Just Do The Right Thing). My online banking almost always prompts me with a message like the following when I access online statements:

34 of 45 transactions have been retrieved and more are available. Display the partial list or retrieve more transactions?

What’s worse is that those 35 are the oldest 35, so if click “Display” (i.e. display the partial list) then I won’t see what I really want: the 10 newest transactions. In this case, the Right Thing is a more sensible limit like 100 transactions and displaying the newest transactions at the top of the page. Currently, my online banking system does nearly the exact opposite.

Sometimes software designers/programmers run into a wall when trying to determine what is the Right Thing for a program because the program is complex and the user may want to do this or that, and there are basic users and advanced users, and users who have RTFM (read the fine manual) and users who never will.

For me, the Right Thing is the most minimal output/result that is useful/informative for a naïve user but intelligent person. Hm, that solution might be more complex than the problem; let me explain…

Firstly, what’s “a naïve user but intelligent person”? I think users want to remain ignorant of a program’s inner workings, bells, and whistles. Users just want results. Users would rather not read the fine manual. Users want programs to Just Do The Right Thing, to be almost magical in their ability to do their work so they (the users) can do their work. Users are and want to be naïve concerning the program. However, the person (i.e. the man or women or other?) running the program is an intelligent, capable human being. Human beings, especially the more and more we live our life with computers, are very adept at learning how to work with, tweak, or change programs. For example, if the Right Thing output is sorted ascending but the person wants descending, that’s a specific tweak that they’ll have no problem making if the program allows the tweak. So, at first the user is going to approach the program naïvely and hope it does the Right Thing. If yes, then great! If no, then the intelligent human being kicks in and they will make whatever changes they need.

The “most minimal output/result” relates to the naïve user/intelligent person. The program probably has a lot of options, different reports, etc. The intelligent person knows this, but the naïve user just wants to see something at first. If that something is what they need, then great! (The program did the Right Thing.) If not, then as mentioned above, the intelligent person will attempt to change that something. Since the program cannot know ahead of time what the user/person wants, it should not try to determine it. However, that does not mean that the program should do nothing because it doesn’t know what the user/person will ultimately want. Therefore…

The most minimal output/result should be “useful/informative”. No output is not useful. Requiring the user to set options or establish parameters before anything can be done is also not useful. Perhaps, JDTRT should be supplemented with JDS: Just Do Something! When a user runs a program, they want to do something; they’re not just trying to waste time. Imagine if you couldn’t start your car until you told it where you’re going. Or, imagine if you couldn’t use a hammer until you set the number of hits you were going to use to drive the nail. Sadly, those over-the-top examples aren’t far from my online banking system: 99% of the time I have to click “More transactions” (then scroll to the bottom of the page). Just show me my damn transactions! What makes useful/informative possible is the intelligent person. Even if the most minimal output/result is really simple, at least it gives the user an idea of what the program does, what the output/result is like, or even if the input is acceptable. Often times the naïve user is only testing the waters. They’re saying “Hello, program!” and waiting to see if the program is friendly or malevolent. Any response displays friendliness; it shows that the program is trying to Do The Right Thing.

Is this impossible? No. Here is an example:

gnuplot> plot "data003.txt"

gnuplot is a very complex program, but a line as simple as the above will generate a plot of the data in that file. In this case, the program is choosing automatically a lot of default values in order to Just Do Something. The plot is not what I want, but that’s ok because now I’ll read its manual to see how to change the line style and add axis labels, etc.

Another example is a program that I and my fellow Percona Toolkit dev teammates just completed: pt-table-checksum. This program is also very complex, and it runs in very complex environments. Yet simply running the program without any options will, on the vast majority of systems, Just Do The Right Thing:

10-20T08:36:50      0      0   200       1       0   0.005 db1.tbl1
10-20T08:36:50      0      0   603       7       0   0.035 db1.tbl2
10-20T08:36:50      0      0    16       1       0   0.003 db2.tbl3

That output probably doesn’t mean anything to you (and there’s no need to explain it), but the point is: the program does everything simply by running it. It’s so adept at Just Doing The Right Thing that most of its options are only needed in weird environments.

Why doesn’t more software JDTRT? In my experience, JDTRT is difficult not only to define but to implement in code. It’s a lot easier for programs to be told, to be configured; it’s a lot more difficult for a program to discover and determine the Right Thing given that programs run in all sorts of environments (and sometimes get input from multiple places in multiple formats). Determining the Right Thing is like a separate program with its own logic. Despite these reasons, more software should JDTRT because software is more than tools to accomplish tasks, it is tools to accomplish tasks more easily, quickly, efficiently, and accurately. One final analogy to drive home the point: users are roofers, programs are hammers, and programs that JDTRT are nail guns.

Written by Daniel Nichter

January 5th, 2012 at 10:37 am

The technical argument against QuiBids

with 5 comments

In my first post The truth about QuiBids I concluded by saying,

The bottom line: penny auction websites like QuiBids are a bad idea because countless people will waste countless hours of their lives only to lose thousands of dollars on a single item which costs, at retail, only a few hundred dollars, and all their lost money becomes the sole profit of the company which cleverly masques the dollars-and-cents reality of its game in a shroud of penny-bid lingo.

QuiBids can make an insane amount of money on an item whereas all players except the one who wins lose a lot of money often times without realizing how much they’ve lost because the penny-bid lingo obfuscates the financial details. However, Kevin (a commenter) pointed out, if you lose you can buy an item outright less the amount you’ve already bid. He is correct and that makes QuiBids less audacious.

There is another aspect to QuiBids and all online auction sites that rely on timing which make them an inescapably bad idea: the technology that makes them work works against you. I have been working in the computer industry for 15+ years, so I’m qualified to reveal to you how technology works against you for sites like QuiBids. I make a disclaimer though: this post won’t have cold hard numbers to support my claims, and I can’t show you the Internet at work, but those with a technical knowledge of code and networks will, I trust, agree with me completely.

First, sites like QuiBids hinge on a clock counting down and resetting when people place bids. How do you suppose this works for, let’s be simple and say just 10 bidders in 5 different timezones? I don’t know QuiBid technical details, but as a programmer myself and looking at the source code of a live auction page, it seems QuiBids uses a combination of Javascript and Flash which communicates with their servers to find out how much time remains for an auction, then displays that time on your screen. This is logical because there must be an authority which 1) determines how much time remains for an auction, 2) resets the time when bids are received, and 3) keeps track of the item’s price and current winner. Why would that authority be anyone other than QuiBids? It would be nearly technologically impossible to track those three bits of information in a distributed fashion, i.e. no central authority but rather synchronizing and communicating between bidders. This is where technology begins to work against you.

As you well know, web pages do not load with a constant response time. There are three very broad, general levels between you and your requested page which account for the different response times. The first level is your computer. If your computer is busy doing other stuff, it may take it a few extra microseconds to full seconds to request, receive, parse, and render the web page, not to mention load and run any Javascript or Flash programs. Or, maybe your compute is just really old so it takes a little longer to do tasks that new computers do more quickly. Or, maybe your Internet connection is slow so information is sent and received more slowly. There are many reasons why your computer can cause delay before you actually see the web page.

The second level is the Internet itself. From my present location, there are at least 10 computers between me and QuiBid’s servers. Each one of those computers is susceptible to the delays just mentioned. So when I try to load an auction, any computer between me and QuiBids may momentarily delay the response from QuiBids, or worse it will drop the response, which my computer will detect and automatically re-request. (Yes, I know it’s not all “computers” between me and QuiBids, there are a lot of routers and other devices, but even routers have loads, prioritization algorithms, throttling, etc.) More problematic at this second level, however, is the time it takes for data to travel between me to QuiBids. This time is called round-trip time (RTT). Round-trip time in the continental U.S., for example, is usually pretty good: tens of milliseconds to a few hundred milliseconds. In other words, it usually takes data about 1/4 second to go from my computer, to QuiBids, and back. If you’re not in America, however, your RTT to QuiBids will be longer. And if you’re on an island, the RTT will probably increase even more. Or, if you use satellite or long-range WiFi your RTT will probably be comparatively huge.

The third level is QuiBids, their servers and databases. Their administrators must be quite talented to keep a complex operation like QuiBids running well (I mean that sincerely; I’m not being facetious), but there’s a technological limitation that no one can bypass: serialization, or marshaling. Because of the aforementioned two levels, data from bidders does not arrive at QuiBids at the same time. Even if it did, for a single auction, there cannot be two winners, so how does QuiBids organize the data? Let’s presume I click to bid at time index 0, and you click to bid at time index 0+0.5, i.e. half a second later. But your computer is faster and the Internet routes your data to QuiBids faster, so although I clicked to bid first, QuiBids receives your bid first, then my bid, and if my bid was the last bid, then I win. It is possible, but highly unlikely that QuiBids is checking and correcting for this problem because there’s only two solutions, which I’ll digress into explaining for the sake of completeness…

The first solution is that our bids are tagged with times. Time index 0 is 00:00:00 GMT-6 (midnight my timezone), but that assumes that the time is actually and accurately 00:00:00 on my computer and on your computer (and every bidder’s computers) accounting for each of our timezones. That’s a very poor assumption because there’s zero guarantee that our computers have accurate and/or synchronized times. Therefore, bids cannot be time-tagged. So the second solution is that QuiBids tries to coordinate or synchronize our bids, but this is impossible because QuiBids cannot have access to anything beyond their servers (and a little bit of access to our computers). QuiBids cannot account for round-trip times or all the computers between them and us.

Back to the third level problems. Let me draw another analogy. Time-based auctions are like hourglasses, and bids are the grains of sand. The last grain of sand to fall through to the other side wins. The narrow part of the hour glass serializes (or marshals) the grains of sand as they pass through because they can’t all pass through at once. By chance, a grain of sand that’s sitting right near the narrow part may pass through early or late. Similarly, our bids arrive at nearly random times (from QuiBid’s point of view), and on top of that, their computers must serialize the information. In an hourglass, physics, friction, etc. dictates the serialization; in a computer, it’s a matter of process schedulers which coordinate thousands of requests to the limited number of CPUs and hard drives.

If you’ve read this far, congratulations! I know the aforementioned information is very dry. Now let’s put it all together to see the technological argument against QuiBids, and all time-based “auction” sites. In an ideal world, when there is 1 second left on the auction clock and I click bid at T-1.0s and you click bid at T-0.5s, you should win because your bid was the last one, half a second after mine. But given the three levels of problems plus the fact that there’s many people bidding at once, how likely do you think it is that the bidding process is fair and accurate? It’s unlikely and completely unreliable. Therefore, playing QuiBids or other time-based “auction” sites is analogous to throwing darts while blindfolded.

I suspect you’ve had an experience similar to mine where I was diligently watching an auction, waiting for those last few seconds, I see 1 seconds remaining, I click to bid but then the site tells me that someone else has won. The three levels (my computer, the Internet, and QuiBids) explain why this happens. My click to bid simply did not arrive or was not processed at QuiBids in that final second. Or, there was never even a full second left because it passed in between my computer asking and receiving from QuiBids the remaining time. Or, who knows… there’s a dark universe of technological processes between that simple bid button on my screen and that bid actually taking affect at QuiBids.

Before concluding, I want to say that QuiBid’s “bid-o-matic” introduces new considerations that I haven’t addressed here but do not negate the technological argument. Secondly, someone asked me what I thought about eBay. In my opinion, eBay is a true, good, and respectable auction site.

If the dollars-and-cents argument against QuiBids doesn’t convince you that you should not waste your time with QuiBids or other time-based “auction” sites, then the technological argument in this post should because there’s nothing wrong with a fair and transparent bidding process, but the technology that makes QuiBids work also makes its auctions unfair and opaque.

Written by Daniel Nichter

January 4th, 2012 at 11:53 am

Posted in lesson

Tagged with , , ,

Document and conquer

without comments

I really hope to see Drizzle succeed, which is why I spent weeks rewriting the Configuration, Administration, and Plugins sections of the Drizzle documentation. Actually, generating the skeleton documentation for all those plugins took a month. I wrote a Perl script that found and parsed the necessary information from the plugins’ C++ source files, then I filled in and cleaned up each one by hand. I think all the new documentation will make Drizzle accessible to normal people, whereas before only developer and hackers could use it.

Written by Daniel Nichter

November 12th, 2011 at 5:04 pm

Posted in Announcement

Tagged with ,

Write off rather than investigate

with one comment

I learned a surprising truth recently when I disputed a $50 charge on my Visa debit card that I didn’t recognize: Visa and the issuing bank write off some disputed transactions rather than investigating them. My request to my bank was simple: which merchant posted the charge? Unless the transaction (“xa” for short) was hacked into the system (unlikely) there must be a merchant ID associated with it. And unless that merchant account was hacked into the system (also unlikely), then there must be a name, address, and telephone number for it. All that doesn’t matter. Because the disputed transaction shows that the card was swiped and the PIN was used, Visa considers that rarely fraudulent, so they simply write off the amount and so does my bank. Zero investigation and Visa refuses to tell my bank who the merchant was. This is epically stupid in my humble opinion. In essence, that xa belongs to me, and I have a right to know who posts xa on my account. But apparently not. So there’s two lessons we can learn. One: if I don’t want to pay for something, I simply dispute the xa and voilà, it’s gone! Two: if I were a malicious hacker with the ability to hack/steal/copy people’s cards and PINs, I would have nothing to fear because Visa won’t investigate.

I know Visa processes hundreds of millions of xa a day, and that my lowly $50 charge means nothing, but it only takes a single broken link to render the whole chain useless.

Written by Daniel Nichter

October 21st, 2011 at 3:47 pm

Posted in lesson

DBI ShowErrorStatement on CentOS 5.6

without comments

DBI ShowErrorStatement doesn’t work on CentOS 5.6 because that version of CentOS still uses DBD::mysql 3.0007. Changelogs for DBI or DBD::mysql do not mention this, but by painstakingly installing different versions of DBD::mysql, I found that ShowErrorStatement works as of DBD::mysql 4.003.

Written by Daniel Nichter

August 24th, 2011 at 10:29 am

Posted in fyi

Tagged with , , ,

Leave Babylon for Babylon

without comments

In the January 31, 2011 print of the New York Times article entitled “At Flickr, Fending Off Rumors and Facebook”, Matthew Rothenberg is quoted as saying,

The goal, Mr. Rothenberg said, is to recall the experience of sharing photos before the digital age, when people would sit together on a couch, thumb through a photo album and tell stories.

“What we are trying to do at Flickr ultimately is to use all these new technologies to get back to that experience–to get back to that rich storytelling experience–and to do it in the only way it can be done, with the technologies of today,” he said.

I disagree with that quote and its underlying idea. In the first part, Mr. Rothenberg accurately recalls a common social experience: sharing photos. If you’re old enough, you’ve had such an experience. Or, if you’re younger, perhaps the only time you’ve experienced that is with your parents and their photo albums.

Where I disagree is the second part, where Mr. Rothenberg says that the “only way” we can return to this experience is with the “technologies of today.” Mr. Rothenberg, I contend, has left Babylon for Babylon.

True, few people actually print photos, put them in a physical photo album, and then sit on a couch and tells stories while thumbing through that album. But we never lost the heart of that experience which is, in Mr. Rothenberg’s words, that “rich storytelling experience.” Since we never lost it, we don’t need to get back to it. Hence the expression “leave Babylon for Babylon” which means: to attempt to obtain something that one already has; or,to leave for a destination which is the same as the point of departure.

Mr. Rothenberg is incorrect in suggesting that our only return to the rich storytelling experience is with the “technologies of today.” By that he seems to suggest that online photo storage services like Flickr are our only option. But that’s far from the truth: we can still buy physical photo albums, and printing pictures from digital cameras is very easy and convenient. And plus, even if a method of doing something is no longer employed, that does not entail that that method is no longer available. So we have gotten away from the rich storytelling experience if online photo storage sites are our only option, but they are not our only option.

I am admittedly belaboring the point and I suspect that Mr. Rothenberg didn’t mean to be taken so literally and critically. My general argument is: technology should not introduce problems.

That seems obvious right now and nobody likes problematic technology, but aren’t we all guilty of hassling with technology? A common problem with technology is an incompatibility between how humans work and how technology works. Some things can be translated into technology without this problem and, better yet, improve how humans work. For example: credit card processing. Before card readers, the Internet and online instant-access banking systems, the paper method (with carbon-copy paper and that manual copy device) was slow and problematic. Conversely, some things do not translate well into technology. The storytelling experience with photo albums is one such thing, at least insofar as Flickr can accomplish with their website.

If Flickr wants my opinion (probably not), this is what they should do: create a tablet app called “Flickr Photo Album”. Make this app as simple as a real photo album. Get rid of “photostream”, searching, tags, contacts–everything that is not in a real, physical photo album. Don’t even “socialize” the app or the albums, that is, don’t make them shareable, postable on Facebook, or anything like that because, again, a real photo album can’t do this. Plus, a photo album should bring real people together in the real world. And make it only an app; don’t try to do this on the website. Tablets are, imho, the next revolution, not because they’re futuristic (like the tablets frequently seen on Stark Trek: TNG), but because they’re tactile and human beings are incessantly tactile. And finally, store the entire album locally (offline, on the tablet) because real photo albums don’t require the Internet.

With an app like that, I could sit on my couch with friends, whip out my handy little iPad and begin flipping through pages of photos, sharing stories as if the technology were not even there.

Written by Daniel Nichter

February 11th, 2011 at 7:28 pm

Equality of intelligence

without comments

Me and a friend like to discuss artificial intelligence with respect to making a program smart enough to learn and pass a modern Turing test. (First let me say that we’re both professionals in the computer science industry and while I have a degree in philosophy and he in computer science, we’re both amateurs in the field of AI, therefore take everything I’m about to say with a grain of salt.) The wish is for a program to be able to “naturally” interact with a human via chat (to avoid further complexities of speech recognition, etc.). Moreover, the wish is that the program doesn’t simply do complex and clever analyses of what it “reads” and chooses appropriate responses, but rather that the program understands what is said and formulates an intelligent response. Thus the aspect of what it means that a program is intelligent or not arises for us.

I’ll be clear from the start that I’m not proposing or even thinking that I could propose any new ideas in the field of AI. My purpose here is to argue for this point: all intelligence is the same, i.e. the equality of intelligence. This argument arises from our common parlance which so often distinguishes between “intelligence”, implying human or biological intelligence, verses “artificial intelligence”. I think that this distinction complicates an already complicated subject and should be avoided.

Ostensibly you believe that I am intelligent. Why? If you don’t know me personally, your only evidence is this blog. If you know me personally, then your additional evidence are social interactions with me. Let’s look at each and see what is really behind my badge of intelligence.

How does this blog convince you that I’m intelligent? The first gut reaction is probably, “It’s obvious that you’re an intelligent agent because the blog posts are sensible, grammatically correct, etc. These kinds of posts don’t just appear randomly, and they’re too long and complex to have been created by some sort of program. They’re obviously the work of an intelligent agent.” That seems a reasonable response to me, but what about this blog post? If you can read French then it’s sensible and obviously written by an intelligent agent. But if you can’t read French then for all you know that post could be random, unintelligible text. Therefore, we discover that the subjective (i.e. personal) sense of sensibly is not a sufficient criteria for determining an agent’s intelligence via the agent’s writing. Yet, not knowing me or other bloggers personally, all you have is our posts, and yet you probably (and rightly) remain convinced that we’re intelligent agents. So while subjective sensibility is not sufficient, I think in the end it is necessary for the following reason. If you wanted to determine if the author of that French blog post is an intelligent agent, you would ask someone to translate the post to a language you understand. Then you could determine if the author is an intelligent agent or not. If no one (or no thing) could translate the post, then you probably (and rightly) conclude that the post was not written by an intelligent agent. Therefore, in the end, your subjective sense of sensibly is necessary even if to apply it you must first translate, decipher, etc.

How does knowing me and having social interactions with me convince you that I’m intelligent? The first gut reaction is probably, “It’s obvious that you’re intelligent because you understand people and respond appropriately, you can do lots of complex tasks like drive a car or program a computer, you display emotions, and you learn new stuff and apply it in your life.” That, of course, provides a lot more tangible evidence that I’m an intelligent agent than do my blog posts. But what really is behind these tangible badges of intelligence? Let’s consider each one.

I understand people and respond appropriately. At first it may seem like that is the telltale sign of an intelligent agent but, in fact, it’s easy to eliminate it. I speak German poorly at the moment. If I were to go to Germany and interact with locals, they would surely understand next to nothing that I said. I would do better to bring my iPad, translate what I want to say, then have the computer speak it for me. In that case, where is the intelligence of the interaction located: in me or in my iPad? My intentions come from my mind, but they’re made accessible and sensible to others only through my iPad. The German locals would doubt my intelligence if it were not for my iPad. Is my intelligence then shared or somehow transferred to my iPad? Perhaps yes, in a manner of speak, because I am the one who tells the iPad what to translate and speak. But you could do the same for me, and thus the issue becomes clouded: whose intelligence is at work? Thus, unless I can express myself intelligently without aides, the fundamental question of “what is it about my understanding and responding to people appropriately” is obfuscated and undercut by the aide. Or, in other words, I’m cheating and misrepresenting myself by not directly expressing myself. Here’s another example: imagine that I’m mentally retarded and barely more intelligent than an infant. Yet I have a dedicated aide who has worked with me since birth. This person translates for me, thus making me appear more intelligent to my interlocutors than I really am. So, concluding this point: being able to understand and respond appropriately in social contexts is not a sufficient condition for identifying intelligent agents.

(Side note to the above: Stephen Hawkings. The computer he uses to speak is not an aide in the sense mentioned above because the device does not translate, it merely speaks for him.)

I can do complex tasks. This is also easy to dismiss. Speaking of Mr. Hawkings again, he can do complex mathematical tasks, yet he cannot walk. Conversely, I can walk but I cannot do the complex mathematical tasks that he can do. Yet we’re both intelligent agents. So being able to do complex tasks, either physical or mental, is also not sufficient for determining if an agent is intelligent or not.

I display emotions. But so what? When I display no emotions my intelligence does not disappear. Emotions and intelligence are independent of one another, therefore having emotions or not says nothing about having intelligence or not.

I learn and apply new stuff. I think this is the most fruitful observation and indication of intelligence. I think we can all agree that if an agent could not, or never, learned and applied new stuff (information, skills, abilities, etc.) then the agent would not be called intelligent. Even dogs learn and apply new skills (or tricks). Dogs aren’t greatly intelligent, but they’re not unintelligent either. Unlike emotions which can exist or not exist independent of intelligence, it seems that the ability to learn and apply cannot be absent from intelligent agents. Someone can stop learning and applying and still be intelligent because the ability still exists, they just no longer exercise it. The important observation is that if a person never learns or applies, then we don’t call them intelligent. This applies to non-persons, like bacteria and plants which don’t seem to learn but rather react and adapt in observable, predictable and explainable ways. Indeed, the more an agent learns and applies, the more intelligent we call them. This is unique to learning and application because an agent is not said to be more intelligent when they feel more (emotions), or do more (complex tasks), or interact/converse more. But if we take this to be true, we’re lead into another problem…

How do we gauge that an agent has learned and applied? This problem leads us in a nice little vicious circle because the answer would probably be something like, “I know that agent Z has learned and applied that knowledge because it can understand and respond appropriately to such and such, (or) it can do such and such complex task…” Sound familiar?

I think the solution that breaks that vicious circle is what we first talked about: our subjective senses of sensibility. In truth, there’s no direct, unequivocal way to know that an agent has actually and truly learned something. Take me, for example: I have learned to program in Perl and I have learned to speak French. How do you know? The evidence is only the tasks I’ve done (i.e. the Perl programs I have written) and conversing to me in French. But those are part of the vicious circle. The only directly, unequivocally proof that I’ve learned is me, my very self, the neural arrangements of my brain, but those are things you cannot access. In lieu of direct access, your only recourse is your sense of whether my programs and French are sensible. Are my programs intelligent? Do I express myself intelligently when speaking French? If yes, then having no better test, you can conclude that I am an intelligent agent. If that doesn’t feel right to you, then turn the table: how do I know you’re an intelligent agent? You would try to convince me by showing me all you can do intelligently, and how disheartened you would feel if I denied all those displays and said I would only call you intelligent if I could be you.

So what does all this mean for my original argument, that all intelligence is the same, i.e. the equality of intelligence? It means that if we were able to write a program that could learn and apply (however it achieved that), and it could demonstrate its intelligence in any manner that you might to convince me of your intelligence, then that program’s intelligence would be no more “artificial” than yours.

Why does this matter to me? I think when we draw the distinction between “artificial intelligence” and just “intelligence” and then begin to think about what “intelligence” means as a precursor to deciding what “artificial intelligence” should aspire to, we establish a goal that cannot be attained because we seek to resolve a difference where there is none.

In conclusion, I think we often come to feel that intelligence is some special or emergent property of our brains. True that even average intelligence is very capable, but I don’t think it’s special, only subtle. Like someone once said about the human brain, if intelligence were simpler, we’d be too simple to understand it. Furthermore, we don’t give ourselves credit where credit is due (or, we don’t compare apples to apples); point in case: it takes every child years of constant learning to develop the foundation of their intelligence. How many programs do we put through 12 years of school (or 16 or 18 years for a bachelors or masters degree)? None as far as I know (has any program ever ran longer than, say, 5 years?) I think intelligent programs are possible and that beginning from the premise that we are not trying to make an “artificial intelligence” but simply an intelligence will open wider the door to success because even our intelligence is not always so spectacular, or as Voltaire said:

Common sense is not so common.

One might say that well-programmed programs already display more common sense in their dispassionate, logical calculations than humans. Perhaps displaying human-like intelligence is closer than we realize.

Written by Daniel Nichter

December 16th, 2010 at 6:22 pm