I’ve put some thought into this during a discussion about the creation of an emotions chip and how one would go about programming emotional responses into a computer or robot.

Consider this hypothetical humanoid example:

John and Matt are friends – they’ve been friends since they were little kids. They like to rough-house, have insult contests to see who can come up with the most insulting quip, and have generally different preferences in women.

While running down the city sidewalk, John takes a physical jab at Matt, Matt reacts with a friendly reciprocal jab. During the horseplay, a bystander gets run into, and also jabbed. The bystander yells out some profanity and insults, and fumes about it the rest of the day.

What psychological forces are in play here? We have John and Matt who are happy and playing, there is a certain level of trust between them that indicates anything John or Matt does to the other is going to be in jest, in accordance with how they’ve each understood the personality of the other. The bystander, however, is not keen on the intentions and understanding of the two boy’s personalities, and considers their horseplay to be rude, disrupting, and inappropriate.

Now, if we were going to mimic this same scenario, but Matt is a robot named M477, we’d need a few things in the computer to interpret and record this data. Here’s the same scenario, but using M477 as John’s childhood toy:

John has owned his robot M477 since he was a child. Over time, M477 has observed and taken note that John likes to rough-house, try to come up with the most creative insults, and likes a particular type of woman.

While running down the city sidewalk, John takes a physical jab at M477, and M477 receives the jab, calculates the perceived force intended (taking into consideration the momentum of the fist and the time at that momentum, the subsequent pull-back of the fist before actually making contact and the time taken to pull-back, and the velocity they were moving down the sidewalk :: v((m*t’) – (p * t”)) = r) and reciprocates with an equally playful jab back. …

What about the Bystander? If you consider the bystander as a robot, BY574ND3R, he is not inherently privy to the trust-factor that M477 and John have between each other, nor does he contain the data that M477 has about John’s personality.

…During the horseplay, BY574ND3R gets run into, and also jabbed. As programmed, when encountering an unexpected result (getting ran into with force, and jabbed, without a display of consideration from the offending party), a calculation is performed (taking into account the current system morale, the inherent non-zero initial level of trust between the offending parties and BY574ND3R, the force of the encounter, and the apparent level of disregard for BY574ND3R’s right to exist in a particular point of space-time :: m * t * f * d = a) the anger emotion triggers – with the intensity gauged by all the variables of the equation, as well as a decrease in BY574ND3R’s system morale.

That’s just two emotions: Comradery and Anger. In this same way, other emotions, and even variables could be affected. For the sake of example, if there were a situation in which exclusivity was promised to a particular computer system for a task, and the Promiser was discovered to be using other systems to perform the same tasks, it would result in a decreased trust level, and a negative value factor applied to the system’s overall morale, and to the system’s certainty of understanding what it’s owner’s desires and expectations are.

And if such a situation would arise that caused the system’s overall morale to drop to a negative value, the system’s performance would be hindered, or stop altogether. Conversely, an increase in system morale would increase the system’s performance. Alternatively, if the system morale was low, and yet a neutral-morale gesture (i.e. John & M477′s playful jabs) were to take place, the response from M477 could be neutral or even negative towards John.

It’s my position that even something as complex as emotions could be represented with an artificially intelligent machine, a database of previous experiences with the user, a running variable of user trust, system morale, and the ability to measure the world around them indirectly, keeping such measurements in virtual memory to be recalled if needed, or discarded after a period of time.

Of course, some of the limitations that humans have with regard to trust and experiences with other human could be overcome in the world of robots. If they were all connected with 4G or better type communications devices and the ability to share their trust levels with regard to humans they have come into contact with (similarly to the word-of-mouth reputation some humans share amongst themselves) via something like “RoboEarth” then perhaps there would be a less intense response from BY574ND3R when he was run into. He would have been told by M477 that this was expected behavior, and nothing malicious was intended by it – it’s just his personality. This shared trust factor would then be weighted based on the length of time the reporting robot has spent with the human in the report.

The issue of human privacy would come into question, since this broadcast would also include personality traits to accompany the level of Trust – otherwise it would be a meaningless number. I’d be inclined to suggest that this is not really an issue, unless the robot knows of things you do that you do not want others to know you do – but then it would be no different than having a human in the room with you while you do those things.

This thought experiment could suggest that having emotions is what makes us “human” – in that there are actions and thoughts we have, and the ability to have them would be passed to robots and machines. I’m inclined to believe then that the ability to harbor the capacity for emotion is then not solely a human characteristic. However, this would obviously create problems in the world productivity, if machines were as susceptible to fluctuations in output as humans are based on environmental conditions. Thus, this is not to say that robots should be permitted to have emotions chips – but merely to conjecture that such a thing could exist given enough storage and experience with the particular user.

Technorati Tags: AI, artificial intelligence, biology, computers, database, emotion, emotions chips, mobile trust sharing, Programming, psychology, robots, technology

My webhost says it is creating a lot of “sleeper” processes on the database server, and using up a lot of the processor resources. My account was even suspended until I fixed it.

SO – I am going to be rewriting the whole thing, pretty much from scratch now, and it will only be loosely based on Dan’s version…

Currently, the code will run through the database of posts, and find those that have shortened URLs stored for them, run a twitter search, and return/parse/store/display the resulting tweetbacks. And it does this every 5 minutes.

However, that sucks up a lot of processing power to do that, especially if you have a big blog, popular blog, or both. The Answer: A Rewrite. This one is going to run a single Twitter search for every shortened url in the database, return ALL the results once, and parse them out, store them in the database, and associate them to their respective parent posts.

So, there’s the update for why this hasn’t been released yet.

I’m also working on trying to get the retro-active TweetThis buttons working on old posts – but something isn’t working right – either it’s the original code that isn’t comparing what’s in the database to the conditional statement correctly (if this.url = “”, then make new ones), or something. It’s going to take some more testing on my own test database, since my webhost is getting antsy with all the processes I’m using.

I’ll keep everyone updated as it moves along. Thanks.

Technorati Tags: api, code, database, MySQL, Ping.fm, plugin, Programming, tweetback, tweetbacks, TweetSuite, webhost, WordPress

Sure enough, Dan Zarrella over at danzarrella.com had. He wrote one for Tweetbacks, and then expanded on it with TweetSuite. So I gave them a shot.

I started with Tweetbacks on the FreeformFrog.com Blog and everything seemed to be working fine – until one day when the Tweetbacks stopped. It just stopped finding them – even though I knew they were getting tweeted – because I was using Ping.fm to syndicate my blog posts to the appropriate social networks.

I gave it a couple weeks, and then decided I was going to fix it. I was tired of not having my TweetBacks working – especially during my efforts pushing a Social Networking campaign at job.

So, I added @danzarrella, and asked…

@danzarrella do you have plans to integrate ping.fm posting in TweetSuite? If not, mind if I take a crack at it?
from @neotsn at 4:32 PM Mar 18th from web

A few minutes later, I got a response…

@neotsn go to town
from @danzarrella at 4:34 PM Mar 18th from TweetDeck in reply to neotsn

Excellent…now I had his blessing to hack his codes. And so I have…

The download is coming soon

I have to get my Ping.fm API Key approved before anyone but me can install the plugin.

And now I present to you a general overview of what I wanted to accomplish, and how I did it. (Please note, this is a GENERAL overview with some examples – it’s not meant to be a how-to, so don’t try to just copy/paste the samples – there is much more to do than can be explained here). Let’s get started…

Objectives…

1. Make it post through Ping.fm – I syndicate all my stuff through twitterfeed.com and it pushes everything out through Ping.fm for me. Upon further investigation, I noticed that TweetSuite used its own publishing code to push out the updates – after it created its own shortened urls and attached them. So of course it would never find my updates – it didn’t know what urls to search for, because it didn’t create them.
2. Make it find my tweets that were pushed through Ping.fm – After realizing that it stopped searching for blog titles and started searching for the shortened urls as the unique identifier on the web, I realized that I needed it to create my urls and push them out with my Ping.fm update text. That was the only way to let TweetSuite know that there were tweets out there about my blog, and obtw here’s the link.
3. Clean up some of the things that were a little messy – Once I got poking around in the code, I noticed that it some parts of it were written a little redundantly, and in order for me to maintain understanding of what was going on, I needed to clean it up a little.

Let’s Code…

Well, for starters, to accomplish #1, I had to write a function that would validate the user’s app key with Ping.fm:
{code type=php}
/* [[Neo]] */
//BEGIN Ping.fm functions
function pingfm_verify() {
// request app key verification
$ch = curl_init();
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_URL, ‘http://api.ping.fm/v1/user.validate’);
curl_setopt($ch, CURLOPT_POSTFIELDS, Array(
‘api_key’ => get_option(‘tweetsuite_ping_api_key’),
‘user_app_key’ => get_option(‘tweetsuite_ping_app_key’)
));
$output = curl_exec($ch);
// update database with response
if (preg_match(‘/OK/’, $output)) {
echo ‘ <strong>Your key has been verified.</strong> Your can now post to your
<a href=”http://www.ping.fm” target=”_blank”>Ping.fm</a> account.’;
update_option(‘tweetsuite_ping_keyVerified’, 1);
} else {
echo (‘<strong>Your key could not be verified.</strong>.’);
update_option(‘tweetsuite_ping_keyVerified’, 0);
return false;
}
}

// END Ping.fm Functions
{/code}
Just your basic curl function to contact http://api.ping.fm/v1/user.validate and pass the api_key and user_app_key to the api, per the API Documentation on user.validate. Depending on the response, store it to the database, and display the appropriate message.

Next, I had to implement the fields to make that happen. We’ll start with the database…
{code type=php}
/* [[Neo]] */
//ADDED:
add_option(‘tweetsuite_ping_api_key’,’333333333333333333333333333333333′);
add_option(‘tweetsuite_ping_app_key’,”);
add_option(‘tweetsuite_use_ping’,0);
add_option(‘tweetsuite_ping_keyVerified’,0);
//END ADD
{/code}
This sticks those fields into the wordpress database table “wp_options” where all the config values go. My developer’s api key, a blank user application key, a field for the checkbox “Do you want to use Ping.fm?” and one for whether or not the user_app_key successfully verified.

Then I create the user interface for those fields (as well as rearrange the rest of the fields since these have to flow right to make sense…
{code type=php}
/* [[Neo]] */
//ADDED:
update_option(‘tweetsuite_ping_app_key’, $_POST['tweetsuite_ping_app_key']);
//END ADD

//tweetsuite_use_ping
($_POST['tweetsuite_use_ping']) ? update_option(‘tweetsuite_use_ping’, 1) : update_option(‘tweetsuite_use_ping’, 0);
{/code}

That part allows the database to be updated with the data from the fields below…
{code type=html}
<!– /* [[Neo]] */ –>
<!– BEGIN ADD –>
<tr valign=”top”>
<th scope=”row”>Ping.fm :: Use Ping.fm to publish new posts (via your default method)?:</th>
<td><INPUT TYPE=CHECKBOX NAME=”tweetsuite_use_ping” <?php if(get_option(‘tweetsuite_use_ping’)) { echo “checked”; } ?>>
<br /><b>["Send a Tweet when you publish" is required for this to work]</b>
</td>
</tr>
<tr valign=”top”>
<th scope=”row”>Ping.fm :: Your Ping.fm <a href=”http://ping.fm/key/” target=”_blank”>Application Key</a>:</th>
<td><INPUT TYPE=text NAME=”tweetsuite_ping_app_key” value=’<?php echo get_option(‘tweetsuite_ping_app_key’); ?>’ /><br /><?php if(get_option(‘tweetsuite_ping_app_key’)) { echo pingfm_verify(); } ?>
</td>
</tr>
<!– END ADD –>
{/code}
This is below the checkbox for “Send a Tweet when you publish a post?”…if that is checked, then if you check “Use Ping.fm to publish new posts (via your default method)?” and fill out the next field for “Your Ping.fm Application Key” then it will send your post details on Publish through Ping.fm instead of Twitter itself, appending the tinyurl associated with the post to your Ping.fm message. All this is done by editing the function that sends the tweets…
{code type=php}
function tweetsuite_send($msg) {
/* [[Neo]] */
//REMOVED:
//$prefix = urlencode(get_option(‘tweetsuite_prefix’).’ ‘);
//REPLACED:
$prefix = (get_option(tweetsuite_use_ping) and get_option(tweetsuite_ping_keyVerified)) ? get_option(‘tweetsuite_prefix’).’ ‘ : urlencode(get_option(‘tweetsuite_prefix’).’ ‘);
$msg = $prefix.$msg;

/* [[Neo]] */
//ADDED
if(get_option(tweetsuite_use_ping) and get_option(tweetsuite_ping_keyVerified)) {
$ch = curl_init();
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_URL, ‘http://api.ping.fm/v1/user.post’);
curl_setopt($ch, CURLOPT_POSTFIELDS, Array(
‘api_key’ => get_option(‘tweetsuite_ping_api_key’),
‘user_app_key’ => get_option(‘tweetsuite_ping_app_key’),
‘post_method’ => “default”,
‘body’ => $msg)
);
$output = curl_exec($ch);
} else {
//END ADD
$username = get_option(‘tweetsuite_twitter_username’);
$password = get_option(‘tweetsuite_twitter_password’);
if(($username) and ($password)) {
$url = ‘http://twitter.com/statuses/update.xml’;
$curl_handle = curl_init();
curl_setopt($curl_handle, CURLOPT_URL, “$url”);
curl_setopt($curl_handle, CURLOPT_CONNECTTIMEOUT, 2);
curl_setopt($curl_handle, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($curl_handle, CURLOPT_POST, 1);
curl_setopt($curl_handle, CURLOPT_POSTFIELDS, “status=$msg”);
curl_setopt($curl_handle, CURLOPT_USERPWD, “$username:$password”);
$buffer = curl_exec($curl_handle);
curl_close($curl_handle);
}
/* [[Neo]] */
//ADDED
}
//END ADD
}
{/code}
This starts off by swapping out the original urlencode() function for a conditional statement deciding if this is a ping.fm post or a twitter post. If it’s a ping.fm post, then we don’t want to urlencode() the prefix, because it sticks + signs where there should be spaces in the prefix to the title. However, if we don’t want to use ping.fm, then don’t mess with the original code.

Following that, it splits which method we used to post, based on the same criteria – make sure the checkbox is true for “tweetsuite_use_ping” and that the user’s app key is verified in “tweetsuite_ping_keyVerified”. If that’s the case, then post it through ping.fm – if any of that is not met, then go ahead and try to post it through twitter. If there is no username and password supplied on the options page, then we just won’t post anything.

Now…about the whole $msg – that part got skipped in the logic of everything. This was the tricky part, for me. Originally, I stumbled across an API Documentation page for the ping.fm method “url.shorten” and that was the very thing I needed – something to grab a ping.fm url, without passing it through ping.fm yet. However, I found out, after much frustration, that this method was mysteriously “depreciated” (which should be read as “edited off the page, and 404′d when you try to use it). But, I found another solution in the knowledgebase at Ping.fm…
{code type=php}
function ts_send_tweet($postID) {
global $wpdb;
if(!is_int($postID))
$postID = $postID->ID;

$table_name = $wpdb->prefix . “shorturls”;
$line = $wpdb->get_row(“select * from $table_name where postID=$postID”);
if($line->postID==$postID) {
/* [[Neo]] */
// ADDED: “*”.
$shorturl = “*”.$line->tinyurl;
$post = get_post($postID);
if(get_option(‘tweetsuite_send_posts’))
tweetsuite_send(trim($post->post_title).’ ‘.$shorturl);
}
}
{/code}
The article said you can prepend a * to the front of a url and it would not shorten it (in addition to the fact that they said they wouldn’t re-shorten any URLs 24 characters or smaller). So, I went with the * solution, because we’re already providing short URLs, but don’t want to risk the functionality in future updates to allow for custom url shortening services.

And that accomplishes both #1 and #2. We have the TweetSuite posting its updates through the Ping.fm API, and pushing a shortened url out with the post. TweetSuite then becomes aware of this url at publish, and stores it in its database. Then the cron job that runs every 5 minutes searches on any version of the URL that was stored and pulls back all the entries from the search.twitter.com Atom feed – parses them, and updates the database with them.

The rest of the stuff I did in the plugin was merely cleaning up…for example, reading the shortened urls from the Atom feed. The original code was:
{code type=php}
if(stristr($tweet, ‘http://bit.ly’)) {
if(strstr($tweet, $bitly)) {
$add = true;
} else {
$add = false;
}
}
{/code}
Because the urls are using alphanumeric sequences to track what link is what – and the url’s are case-sensitive, it was returning links that were not related to the post. For example, I got someone’s tweet about Rush Limbaugh because the bit.ly url (“http://bit.ly/fyhz”)was the same letters, but in a different case then my original “http://bit.ly/FyhZ”. So I changed the order of the search, did it for all the services currently supported, and cleaned up the code a little:
{code type=php}…
if(strstr($tweet, ‘http://bit.ly’)) { $add = (stristr($tweet, $bitly)) ? true : false; } else {
…
{/code}
The function strstr() is not case-sensitive, and that’s ok for a search on the domain name – we want anything that looks close to “bit.ly” to return positive. However, once it does, it’s imperitive that we use the case-sensitive stristr() function to return a positive result only if the full url matches what we have in the database case-for-case.

Wrapping up…

I made a couple more additions to the code beyond that, some of them required for functionality, some of them for cosmetics. I’ve submitted my plugin version to Ping.fm to approve it, and take my Developer’s Key out of “Pending” status. Once that’s done, I’ll send it off to Dan Zarrella to take a look and see how he wants to move forward. Then I’ll be able to post the plugin for download (definitely here, but also on the WordPress Plugin directory.

Continuing on…

I have read through the comments on Dan’s blog from the people, and have taken note of the things that they are asking for. After reading the code, he had already been working on some of the features. There are 5 main ones that people are asking for, and I’ve already done one of them in this release:

1. TweetThis link opens in a new window.
2. AutoUpgrade via WordPress Plugin Directory
3. Allow customized URL Shortening Services
4. TweetThis links for pre-installation posts
5. TweetThis links on the home page.

I’ll be looking more into the other options and see what I can do.

One More Thing…

This post was syndicated through the TweetSuite + Ping.fm plugin .

Technorati Tags: beta, dan zarrella, database, internet, MySQL, PHP, Ping.fm, site, syndication, tweetbacks, TweetSuite, twitter, WordPress

The folks over at www.phpbb.com have released version 3.0.0 of their forum software, and it has all the functions and features that we used in tsnX built-in to it, and everything works right out of the box. So I have gone through and done the conversion of the database, and am in the processing of setting up the permissions and fixing up the forum structure to make get most of it back to the way it was, and some of it optimized and combined for fewer forums.

I’ll have another follow-up post about what’s different that I changed during the conversion, and there will be a forum for things that changed because of the upgrade for everyone to post in.

The only drawback for now is that there is no My Spot page until I get it written again.

Technorati Tags: conversion, database, forum, forum software, forum structure, phpbb, tsn, tsnX, upgrade

I’ve gotten the posts and post data sync’d to the other database when posts are made, and right now I’m working on filtering out the BBCode that gets inserted into all the posts. I’ve so far gotten out the bold, underline, italics, and url codes. Next I have to figure out how I want to format the quote code so that it makes sense when it’s read in RSS. After I get a few more BBCodes filtered out, I’ll figure out what I want to do with the smilies, and then implement it into the site.

Technorati Tags: bbcode, bbcodes, database, phpbb, post, RSS, site, url

I’m currently working on the first theme for the site, named tsnX-lite. It is available for you to use as your own, simply change the setting in your Profile. Once the theme is mostly complete, I’ll begin work on coding the MySpot page.

The MySpot page will be making use of some AJAX techniques, as well as customizeable options, like the presence of certain content boxes. There will be more to come on the MySpot page as the time gets closer.

Technorati Tags: ajax, content, database, myspot, Profile, site, theme, tsnX, update

So check the pizzy for updates if the forums aren’t working. If, in the meantime, the server goes down for some reason, and you can’t get to thepizzy or tsn, then go to http://tsnblog.blogspot.com to fing out why.

Technorati Tags: beta, code, conversions, database, forums, pizzy, server, site, sql, sql code, tsn, tsnV, tsnX, update

I spent all night working on it, and then another 3 hours today already, and am going to take a break from it. But once the database conversion is finished, and I revisit the bugs in the code, I’ll load the database, and start working on the site design.

The theme that I’m going to be working off of is just going to be a re-coded subSilver theme. If you want to use the theme as I build it, to be one of the first to experience the tsnX feel, then feel free to do so. However, the theme is going to be in the alpha phase, which will guarantee nothing as far as it’s ability to function is concerned. So if I’m working on something, and the theme breaks, and it’s not something that I can fix immediately, then you will most likely be SOL until I get it fixed, as far as using the site is concerned.

For this purpose if you wish to create a separate user on the site and use the settings for it to work with everything beta, then that will be acceptable. Just name your user account _beta so that you can distinguish which is which, and we’ll still know who you are.

Technorati Tags: account, alpha, alpha phase, beta, code, database, database conversion, database structure, design, forums, site, subSilver, tsnV, tsnX, update, user, user accounts

What’s next on the list, is debugging some of the beta problems…then converting the tsnV database to work with the tsnX database, and then working on the design of the forums.

Once that is done, I’ll start the work on the My Spot page, and the design for that page. So it’s coming together, and people can start coming back soon…and within the next couple days, everyone will be able to log back in as before.

More updates to come, as more progress is made.

Technorati Tags: beta, Coding, database, design, feature, forums, progress, Spot, tsnV, tsnX, update

Nerd Night @ Neo’s is brought to you by Google Adsense (click the ads, plz – help pay for this crap), and by Beef Jerky (get your Jerk on).

We are going to work on winkydo.net/blog and /teck because the WordPress auto-update that I have on the server is, in my opinion, not going to work properly. When wizard changed his blogs from /blog (teck news) and /Jeromy (person) to /teck and /blog, respectively, the file that shows what is installed on the server did not update. This was because he did the switch by hand with the database, and file system. Now, the data file that shows what is installed can’t find /Jeromy, but it does see /blog, because that directory never changed. However, the database associated with that directory is not the same as it was…so if I were to update /blog it would change the teck database it was created with, and the /blog files that it references – causing an updated DB for the /teck journal, and updated files for the /blog journal – but not the files and DB for the other, respectively. So we’ll be backing up both blogs, reinstalling them from scratch, and re-uploading the database for each to get things in the right order.

Also, I’m going to be working on tsnX and getting the last 3 code changes done before I have to start writing my paper, and preparing for final exams. We’re also probably going to give Podcasting a shot, and call it The-Spotcast (for being in a different spot each time, possibly). We’ll probably do the recording in Downtown Fort Worth. We gave things a test-run at Billy Miner’s in Sundance Square. We found a couple good spots, the only problem is the noise, but I believe we’ll be able to do better this time. We’ve not decided on what all we want to discuss just yet, but when we get together, there is always teck news and ideas that spew forth.

When we get our spotcasting under way, I’ll start a link collection here on thepizzy.net as well as in the-spot.net/forums. There is going to be a Podcasting icon in the profile of each user to get their latest podcast. I’ll be setting one up for us. There are so many directions we can go with it, and we haven’t thought of them all yet – but it’s been a project that we’ve wanted to do for about a year now, and finally have all the equipment…including a video recorder.

That’s the jist of what’s going down this Nerd Night @ Neo’s.

Technorati Tags: Adsense, billy miner, blog, database, directory, Fort Worth, google, graphic redesign, Neo, nerd night, news, Podcasting, Spotcast, sundance square, teck, video, winkydo, WordPress