Attended the Atlanta Board and Card Games Meetup this evening, hosted at the Loop Pizza Grill on Chamblee-Tucker. It’s a long drive to get there but well worth it. It was an excellent social event and a great opportunity for board and card game players alike to gather for fun and games. It also seems like a wonderful way to wind down after a long day at work. I had the chance to play Ticket to Ride and Acquire, and met a few more Atlanta residents along the way.

Lori is hosting a little shindig for bloggers on Thursday night at the Righteous Room. If you’re in the Atlanta area, please let her know, and she’ll send you the invitation with additional details. Looking forward to attending myself.

I have some sad news to bear. Dr. Kelly Dunagan passed away today at 1:00 p.m. His service will be held at First Methodist Church in Pensacola. He was an amazing professor who taught me everything I know about Integral Calculus. He had a unique sense of humor and a genuine care for his students that will never be forgotten by those who knew him. The Alabama School of Math and Science community is like a family to me, and it makes it that much harder to lose someone in that community. A wonderful way to remember Dr. Dunagan would be to make a donation in his name to the ASMS Foundation or to the cancer research charity of your choice.

In this entry, we take a brief look at the use of the open source gcc compiler and NASM assembler to generate a basic "Hello, world" application. First, let’s look at an example that uses the C Standard Library. This example illustrates how one might call C functions, such as printf from within assembly:

section .data
msg db "Hello world!", 0x0A, 0x0

   section .text
   global main
   extern printf

main:
   push dword msg
   call printf
   add esp, 4
   ret

We create an object file and then pass the resulting object to gcc in order to link it with the C Standard Library:

nasm -f elf hello_gcc.asm
gcc hello_gcc.o -o hello_gcc

Alternatively, we can skip the C libraries entirely and use the kernel system call (through interrupt 0×80) to print our string:

section .data

msg db "Hello, world!",0xA
len equ $ - msg

section .text

   global _start

_start:

   mov edx, len
   mov ecx, msg
   mov ebx, 1
   mov eax, 4
   int 0x80

   mov ebx, 0
   mov eax, 1
   int 0x80

Compilation is once again very similar:

nasm -f elf hello_kernel.asm
ld hello_kernel.asm -o hello_kernel

Crafty spammers wage a high-tech game of cat-and-mouse, and about once every year I spend some time tweaking and updating filters to respond to new threats. While mortgage, pornography, and virus e-mails are now effectively caught, there’s an insurgence of recent pharmaceutical junk mail that my filters haven’t quite been able to cope with. Until now.

SpamAssassin 3.0 includes new static rules, and with it a rule set to detect common pill spam. It’s also a major upgrade from my previous 2.6.3 installation, and comes with a host of other features. Here’s an overview of the techniques I use to fight, and hopefully win, the war against spam. As a bonus, all of these tools seamlessly integrate with SpamAssassin:

• Pyzor is collaborative, networked system to detect and block spam using identifying digests of messages. It is written in Python.
• Vipul’s Razor is another very popular distributed spam catalog and filter system. Detection is done with statistical and randomized signatures that efficiently spot mutating spam content.
• Distributed Checksum Clearinghouse is a system of millions of users, tens of thousands of clients and more than 250 servers collecting and counting checksums related to more than 150 million mail messages on week days. The counts can be used by SMTP servers and mail user agents to detect and reject or filter spam or unsolicited bulk mail.
• The Sender Policy Framework is rapidly gaining momentum with large e-mail providers such as American Online and Google. It should help minimize joe-jobs from large providers.
• Spamhaus provides the SBL, a realtime database of IP addresses of verified spam sources (including spammers, spam gangs and spam support services), maintained by the Spamhaus Project team and supplied as a free service to help email administrators better manage incoming email streams.
• Spamhaus also offers the URIDNSBL. While e-mail headers can be forged, spammers can’t hide the the URLs of the web sites that they are promoting. The URIDNSBL plugin checks URLs in message bodies against online blacklists of spammer-operated web sites. It’s very effective, and it’s nailing just about any spam that comes my way.
• Hashcash detects ham, not spam. A hashcash stamp constitutes a proof-of-work which takes a parameterizable amount of work to compute for the sender. The recipient can verify received hashcash stamps efficiently. It takes about two to three seconds of processing time per e-mail to compute a valid hashcash stamp.
• And finally, one of my personal favorites, though it’s been less and less effective against spam each year. The Bayesian classifier tries to identify spam by looking at words or short character sequences that are commonly found in spam or ham. The classifier must be personally trained for maximum effectiveness.

While I doubt that spam will ever go away, as long as it doesn’t land in my inbox, that’s good enough for me. Bring it on.

Jellyvision, makers of the popular You Don’t Know Jack series, demo their Interactive Conversation Interface (iCi) technology, an alternative approach to artificial intelligence and human-machine interfaces. It works by utilizing the insight of writers and actors to determine, for every choice a user makes, an intelligent response for a prerecorded character, with branching scripts and prerecorded audio files programmed to play in response to specific user input. What makes it all work together so effortlessly is their use of The Jack Principles, which outlines the key rules necessary for that final human element, that is, to create the sense that there’s a real human being with you just behind the screen. I found these principles general enough to where I thought it’d be worth sharing here.

The Jack Principles are divided into three basic sections: maintaining pacing, creating the illusion of awareness, and maintaining the illusion of awareness. The full document has more details; I’ll just hit the bullet points below.

Maintain Pacing

1. Give the user only one task to accomplish at a time
2. Limit the number of choices the user has at any one time
3. Give the user only meaningful choices
4. Make sure the user knows what to do at every moment
5. Focus the user’s attention on the task at hand
6. Use the most efficient manner of user input
7. Make the user aware that the program is waiting
8. Pause, quit or move on without the user’s response if it doesn’t come soon enough.

Create the Illusion of Awareness

Respond with human intelligence and emotion to:

1. The user’s actions
2. The user’s inactions
3. The user’s past actions
4. A series of the user’s actions
5. The actual time and space that the user is in
6. The comparison of different users’ situations and actions

Maintain the Illusion of Awareness

1. Use dialogue that conveys a sense of intimacy
2. Make sure characters act appropriately while the user is interacting
3. Make sure dialogue never seems to repeat
4. Be aware of the number of simultaneous users
5. Be aware of the gender of the users
6. Make sure the performance of dialogue is seamless
7. Avoid the presence of characters when user input cannot be evaluated