This last week I was promoted to Client Software Development Lead. I am excited to take on the role and cannot wait to see what I can accomplish. It seems, for now, that my goals are fairly cursory for a lead position:

1. Establish a general culture of documentation. Whether it be a change list for certain libraries, classes, JavaDoc, or APIs us developers tend to have a hard time keeping track of the things we write and then keeping those things up to date as things change.
2. Unit testing. At least for things in our libraries. Understandably, mobile software tends to have more user interaction code where this is not unit testable. However, there are several key library packages that handle data, network, databases, and other things which can be unit tested.
3. Get the team communication flowing. This involves communication both internally and externally. Each team member can potentially disappear in a cave and then we may be unaware of what that member has been up to and conversely, that member may have no idea where things are headed. I think regularly discussing and sharing the trials and triumphs of the week encourages team cohesion although if you add donuts to the equation the effects are much more effective.

These are just some rough outlines of what I’d like to do. Obviously, I still have my work as a developer. There are quite a few other things to do and watch. Overall, I think things I listed here, again, are pretty normal to hear from things that teams can be doing better.

However, according to some of the posts with similar symptoms, end users were experiencing the issue on app upgrade!

While developing recently I ran into this problem and it drove me crazy. I had spent some time trying to trouble shoot restarting the device, my dev machine, Eclipse, the ADB; all to no avail. Uninstalling the app didn’t work either.

I eventually got a work around where I was able to delete the shared preferences directory and its contents which then reinstalling the app allowed it to function correctly. After this point I am trying to uninstall the app and then install it — via command line script.

public void mySuperExample() {
    // A generic list
    ArrayList<SomeObj> someObjList = new ArrayList<SomeObj>();

    // Start off by creating or using generic objs
    SomeObj obj1 = SomeObj.createMe();
    obj1.setSomeAttribute("My super object");
    obj1.setAnotherAttribute(3);

    SomeObj obj2 = SomeObj.createMe();
    obj2.setSomeAttribute("My other super object");
    obj2.setAnotherAttribute(2);

    // Add the objects to the list
    someObjList.add(obj1);
    someObjList.add(obj2);

    // A couple different objects use a copy of the list
    ConsumingObj.useMe(someObjList);
    AnotherConsumer.useMe(someObjList);
}

Now, this looks perfectly fine for ConsumingObj and AnotherConsumer are both unique as are both instances on someObjList. Oh, here is where it gets good. The members of each of the instances of someObjList are identical! The toString() methods have been wonderful to figure this out but basically each of these items were referenced by the parents which ultimately meant that when I thought I had different sets of identical items I had different sets referencing the same items. Anyway, now that that’s over I can move on. It was interesting. This and recently having learned about creating callbacks/event handlers. I love programming and learning!

Moving on, we are pretty much settled at our new house. I road the SoundRunner on Monday which was free (for the inaugural day) and it was quite convenient. My commute wasn’t much shorter than it was in Fife and I think it costs about the same maybe a dollar or two more. But the important part was that there exists a passenger boat straight to Kingston. There is also the Bainbridge Island and Kingston regular ferries so there are like 3 different ways to get to Seattle and back using public transportation.

Although I love the house and location I do lament a little the fact that it is much harder to do some of the shopping I like to do. There is no Nordstrom (or Rack), European butchers, and general conveniences of having everything close by. It’s okay because we never went to those places on a daily basis and they are accessible if I want to go to Seattle. I will take this over urban living any day. The main detractor is being away from my mom and dad and other folks that would visit more frequently. Out here, apart from Crystal’s mom who lives close by, no one has come out to see us. I suspect it will stay that way.

I’ve had enjoyment out of getting acquainted with living in more space and having to do things like monitor gas usage, yard work (what little there is), cooking on gas, playing music loud, and sleeping in complete silence. Today a heavy fog filled the Sound around our area and I heard the rhythmic announcement from the fog horn. Sound of music compared to what we heard in Fife.

I am currently trying to acquire something to reduce the heat on gas stoves. There are these iron plates you can find about eight inches in diameter. With such a huge kitchen the desire to cook is stronger then ever before. I am checking into making cheese and smoking some meats. Soon enough! I got a shelf for the garage to help stow some extra supplies and foods. We’re hoping that when a need arises we’re never caught without a way to take care of ourselves.

Our business is coming along nicely in that we’re generating some income but more importantly we’re solid at work. I am working from home most of the week and my partner John is also doing huge work. We’re trying to make steady improvements to released software and create new stuff. I am working on a game right now. John’s working on an aggregation software. We also did some work to shore up our website and the various places we get found on the Internet.

I’ve been playing World of Tanks here and there. I finally earned enough points to purchase a Panther tank so it’s been super exciting to play that. I really enjoy the aspect to playing history. I think the game is pretty shallow and although the developers say they will be adding more stuff I am going to wait and see. Interestingly a lot of MMORPGs have been going free. After Final Fantasy XIV bombed (they got a 4 out of 10 rating on some sites) I gave up on the MMO scene. Everquest II and Lord of the Rings Online are now free to play minus a few features. Amazing actually. “Freemium” seems to be the next direction MMOs are taking. I think I remember someone at ArenaNet saying that the money earned seems to be about the same as paid subscription. We’ll see. Speaking of ArenaNet, the media blitz in anticipation of Guild Wars 2 is growing but I admit I am still tired of the graphics and play style the studio puts out. Whether I worked for them or not, I always felt that something was off playing the games they made.

To summarize briefly, asynchronous calls are made from the client web browser which are then processed by the server without making sure previous requests are completed. A lot of solutions seem to focus on the front end using Javascript to prevent this. Although it is a good practice to avoid making rapid requests of your server from the client, you will still need to address this issue on the back end. I am sure we can come up with ways to help mitigate this issue but eventually the back end must always be the final say in serving requests relying on nothing from the client.

/**
 * Create and release database locks to prevent concurrency issues. This is a rough
 * solution and you may want to look at try-catch, closing db connections, throwing
 * exceptions, etc.
 *
 * Also, keep in mind that using persistent connections isn't ideal and neither is
 * sleep. This isn't an ideal solution, IMHO.
 *
 * @author Michael Hradek
 */
final class DatabaseLock
{
    /**
	 * @var int Seconds before lock times out.
	 */
    const LOCK_TIMEOUT = 10;

    /**
     * @var int Retry limit count.
     */
    const LOCK_RETRY_LIMIT = 5;

    /**
 	 * Create a lock using MySQL. This is a wrapper for that functionality.
	 *
 	 * @param String
	 */
    public static function lock($lock_name)
    {
        $i = 0;
        do
        {
            if(self::isLockUsed($lock_name) === false)
            {
                $dbObj = /** Your DB obj instantiation. Persistant connection. */
                $sql = "SELECT GET_LOCK(?, ?)";
                $result = $dbObj->query($sql, $lock_name, self::LOCK_TIMEOUT);
                if($result && $result->getColumn(0) === 1) {
                    return true;
                }
            }
            usleep(1000); $i++;
        } while ($i < self::LOCK_RETRY_LIMIT);

        return false;
    }

    /**
 	 * Release an existing lock.
	 *
 	 * @param String
	 */
    public static function release($lock_name)
    {
        $dbObj = /** Your DB obj instantiation. */
        $sql = "SELECT RELEASE_LOCK(?)";
        $result = $dbObj->query($sql, $lock_name);

        if($result && $result->getColumn(0) === 1) {
            return true;
        }

        return false;
    }

	/**
	 * Checks to see if a lockname is in use. Calling GET_LOCK release previous
	 * lock if the lock name is identical.
	 *
	 * @param String
	 * @return bool
	 */
	private static function isLockUsed($lock_name)
	{
        $dbObj = /** Your DB obj instantiation. */
		$sql = "SELECT IS_USED_LOCK(?)";
		$result = $dbObj->query($sql, $lock_name);

		return ($result === false);
	}
}

The solution my colleagues and I came up with above requires use of MySQL’s get_lock and release_lock functionality. We spent some time thinking about Session flags/semaphores, horribly un-scalable sleeping, and semaphores via PHP itself. In the case of session flags we found that session was too slow to keep up with multiple incoming requests. We had between four to six to n requests come through and announce that they are starting the session lock. Wha?!

This solution requires InnoDB and a version of MySQL that allows locking. I believe that in conjunction with solid abuse monitoring on the web server side we create a solution that ensures served requests are not abusive and properly handled. Is it scalable? Better than say sleep but still can have problems. Any time we introduce code dealing with timing out we run the risk of trouble. Also, according to the MySQL documentation calling get_lock multiple times overrides the previous lock so you must check to see if its currently in use before calling it.

We’ve (Koa + me = MokaSocial, LLC) finally pushed out Flicka.mobi the official portal to Flicka, our Flickr application for the Android platform! It will bring all the free functionality of the Flickr website and add tons of integration into the mobile platform. We’re hoping to be able to launch the actual application by the beginning of Q2 this year. We’ll see.

The page kind of tells you about the release and stuff but here are all the links:

• Blog – http://flickamobi.tumblr.com/
• Flickr App Garden – http://www.flickr.com/services/apps/72157623025084241/
• Facebook – http://www.facebook.com/pages/Flicka/189775049761
• Twitter (of our Pivotal Tracker feed) – http://twitter.com/flickamobi
• Get Satisfaction – http://getsatisfaction.com/flicka

It’s been one frantic push to get the code base stabilized and things to a place where we can finally start talking about it. There isn’t much about the Google Android SDK on the web so that’s probably the biggest challenge. Also, the Java library we’re using for our interactions doesn’t seem to have everything.

Anyway, it’s been a wonderful dive into Java and I’ve been thoroughly enjoying it. We’re hoping it’s a successful mobile platform application; one in a series of many increasingly complex and sexy!

Special thanks to those that have been helping. The organization, insight, and comradeship has been awesome!

A while ago I came up with a rate limiting class. It wasn’t as thoroughly tested as I would hope as I left a little over a week after putting this together there, but basically we use time as a cross thread limiter for all connections. If we wanted to limit a particular user, then we’d simply have to create a unique key for the memcache entry for each user.

This logic uses time (as Unix timestamps with microseconds) as a method to “charge” each request against the server a “fee” which accrues against the max or limit. As time moves forward, it removes accrued cost from the memcache saved value.

The beauty of doing rate limiting in code is it allows the developer to manage flow and how limits are handled to protect our databases and CPU load; dishing out less expensive and properly (and expected) formed API responses.

Here’s the code:

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
// 	RATE LIMITER CLASS - rateLimiter.class.php
//
// 	@date:	2009.05.21
// 	@author 	Michael Hradek
// 	@version 	1.0.0
// 	@license 	Apache License, Version 2.0
//
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////
// INCLUDES
////////////////////////////////////////////////////////////////////////////

require_once("initializeMemcache.class.php");

////////////////////////////////////////////////////////////////////////////
// PRIMARY CLASS
////////////////////////////////////////////////////////////////////////////

class rateLimiter
{
    private $rateLimitKey;
    private $rateLimitMax;
    private $rateLimitCost;

    private $memcache;

    function __construct($rateLimitMax, $rateLimitCost,
                         $rateLimitKey = "rate_limiter_key")
    {
        $this->rateLimitMax = (float)$rateLimitMax;
        $this->rateLimitCost = (float)$rateLimitCost;
        $this->rateLimitKey	= $rateLimitKey;

        // Initialize your memcache. This is just one way of initializing it.
        $this->memcache	= InitializeMemcache::initMemcache();
    }

    public function enforceRateLimit()
    {
        $rateLimitDataMs = $this->memcache->get($this->rateLimitKey);
        list($partMsec, $partSec) = explode(" ", microtime());
        $currentTimeMs = $partSec.$partMsec;
        if($rateLimitDataMs === false)
        {
            $this->memcache->set($this->rateLimitKey, $currentTimeMs,
                                 MEMCACHE_COMPRESSED);
            return true;
        }

        $timeDiffMs = $rateLimitDataMs - $currentTimeMs;
        if($timeDiffMs < 0) {
            $rateLimitDataMs = $currentTimeMs;
        }

        $rateLimitDataMs += $this->rateLimitCost;
        if($timeDiffMs < $this->rateLimitMax)
        {
            if(!$this->memcache->replace($this->rateLimitKey,
                                $rateLimitDataMs, MEMCACHE_COMPRESSED)) {
                $this->memcache->set($this->rateLimitKey, $rateLimitDataMs,
                                     MEMCACHE_COMPRESSED);
            }

            return true;
        }

        $rateLimitDataMs += ($this->rateLimitCost*2);
        if(!$this->memcache->replace($this->rateLimitKey, $rateLimitDataMs,
                                     MEMCACHE_COMPRESSED)) {
            $this->memcache->set($this->rateLimitKey, $rateLimitDataMs,
                                 MEMCACHE_COMPRESSED);
        }

        error_log(get_class().": Rate limit enforced.");
        return false;
    }
}

The memcache class is simply something that reads memcache server configuration arrays and loads them into a memcache handle and returns it. I think with some larger volumes we can excuse things like misses in key lookups. We’re already using a hashed configuration. Why add the trouble of retrying?

public static function the_answer_to_life_the_universe_and_everything() {

    $calculation = sqrt(9) * 12;
    $calculation = pow($calculation, 2);
    $calculation = ($calculation / 4);
    $calculation = ($calculation - 4);
    $calculation = ($calculation / 10);
    $calculation = ($calculation + 10);

    return $calculation;
}

Brilliant. +2 Intelligence, +4 Charisma if you get the reference. Yes, this made my day and yes, it was worthy of a blog post.

CREATE PROCEDURE p_getDBInfo(IN inputTable char(30), IN inputOrder char(10), IN inputColumn char(20), IN inputFrom INT, IN inputMax INT, IN inputName char(25), IN inputTag char(4), OUT outputQuery varchar(4000))
LANGUAGE SQL
NOT DETERMINISTIC
SQL SECURITY INVOKER
COMMENT ""

BEGIN
    DECLARE query varchar(4000);
	DECLARE debug int; 

    SET debug = 1;
    SET outputQuery = "";
    SET @query = "SELECT Ranks, Names, Tags,
                  Territory, Ratings, Wins, Losses FROM";

    IF inputTable IS NOT NULL THEN
	SET @query = CONCAT(@query, " ", inputTable);
    ELSE
	SET @query = CONCAT(@query, " ladder_world");
    END IF;

    IF inputName IS NOT NULL || inputTag IS NOT NULL THEN
	SET @query = CONCAT(@query, " WHERE");
    END IF;

    IF inputName IS NOT NULL THEN
	SET @query = CONCAT(@query, " Names LIKE ", inputName);
    END IF; 

    IF inputName IS NOT NULL && inputTag IS NOT NULL THEN
	SET @query = CONCAT(@query, " AND");
    END IF;

    IF inputTag IS NOT NULL THEN
	SET @query = CONCAT(@query, " Tags LIKE ", inputTag);
    END IF; 

    IF inputColumn IS NOT NULL THEN
	SET @query = CONCAT(@query, " ORDER BY ", inputColumn);
    ELSE
	SET @query = CONCAT(@query, " ORDER BY Ranks");
    END IF; 

    IF inputOrder IS NOT NULL THEN
	SET @query = CONCAT(@query, " ", inputOrder);
    ELSE
	SET @query = CONCAT(@query, " ASC");
    END IF;

    IF inputFrom IS NOT NULL THEN
	SET @query = CONCAT(@query, " LIMIT ", inputFrom);
    ELSE
	SET @query = CONCAT(@query, " LIMIT 0");
    END IF;

    IF inputMax IS NOT NULL THEN
	SET @query = CONCAT(@query, ", ", inputMax);
    ELSE
	SET @query = CONCAT(@query, ", 20");
    END IF; 

    IF debug = 1 THEN
	SET outputQuery = @query;
    END IF;

    PREPARE pst FROM @query;
    EXECUTE pst;
    DEALLOCATE PREPARE pst;
END;

To execute this stored procedure with PHP 5 with MySQL 5 you would:

$link = mysqli_connect("localhost", "username", "password", "ladder");
    $query = mysqli_multi_query($link, "CALL p_getDBInfo(null, null, null, null, null, null, null, @a)") or die(mysql_error());
    if ($result = mysqli_store_result($link))
    {
	while ($row = mysqli_fetch_row($result)) {
		print_r($row);
        }
	mysqli_free_result($result);
    }

mysqli_close($link);

From what I’ve read the procedural language is very much like PASCAL but I wouldn’t know. I recognize the IF… END IF; from my computer science classes and stuff. Anyway, I need to rework the connection tools I put together. We’ll see.