Becky got a baby raptor companion pet last night on the WoW 3.2 PTR. She said it was her fifth run through the instance, which means it’s about a 1 in 100 drop rate, similar to the Sprite Darter in Feralas.

My wife wanted to know if it was worth going Engineering on a Troll hunter and lose the +1% crit bonus to bows to use crafted shot instead.

Think about crit this way:
- For the sake of argument, you hit the mobs for 150 with a shot with
vendor ammo. You fire a shot every 2.7 seconds, and your hit is 2.2%,
meaning your miss rate is 3.7%, giving an effective hit of 144.45. Your
ideal DPS is 55.56, but with your miss, you’re really down to 53.5 DPS.
- 1% crit means one out of 100 shots will crit for up to double damage.
For the purpose of this discussion, we’ll assume it always does double
damage.
- In case A, we’ll say you have +3% crit for this discussion, or 8% crit
actual, which means your damage effective over 300 shots is (144.45 * 300
shots + 150 * 24 crits) or 43335 + 3600 = 46,935 damage, or effective
57.94 DPS
- In case B, we’ll say you have +2% crit, or 7% crit actual, which means
your damage effective over 300 shots is (21 crits) 43335 + 3150 = 46,485
damage or effective 57.39 DPS.

—-
So, as was said on Wowwiki:
What’s better, +to hit or +crit?

In principle they are equal. Which is better depends on circumstances. An
increase in hit rate will usually yield a constant level of damage,
whereas a high crit chance gives a spiky, more random damage distribution
over time.

(With the additional caveat that crits are sometimes dropped because the
attack table is full against a mob, and crits are rolled separately.)
—-

You can see when comparing 57.94 DPS versus 57.39 DPS that they’re almost
equal, and that the difference of .5 DPS from using crafted shot negates
the penalty for not using bows.

Totally worth being 30 minutes later for the bus…

Becky tamed King Krush Friday morning in Sholozar Basin on Amau, her Kirin Tor Hunter. She had to make a set of 24k HP armor, grab the right equipment and enchants, carry around haste potions, stamina scrolls, etc., but she got him!

The first tame attempt killed her as Krush got a series of critical hits on her. The second attempt was after Krush and a friendly group of Mammoths killed an Undead Mage who tried to get the rare mob, but this one succeeded.

She’s one of the first hunters on the server with the Dinosaur and she keeps getting looks from Horde and whispers from Alliance Hunters who can’t believe she managed to get such a difficult and rare tame.

Would anyone like to point out the problems in the following block of code? I’ve tested it and haven’t found any problems with it as a form of mutex locking between tasks in Stackless Python.


# locks
locks = {}
 
# waiting locks
queue = {}
 
# lock request channel    
lock_manager_channel = stackless.channel()
 
# controls lock manager
stopManager = Signal()
 
def acquire(caller, lck):
    """Acquire a lock from within a tasklet."""
    if not stopManager:
        lock_wait_channel = stackless.channel()
        lock_manager_channel.send((lck, lock_wait_channel, caller))
        # block until lock acquired
        lock_wait_channel.receive()
    else:
        raise LockManagerStoppedException("Lock manager stopped.")
    
def release(caller, lck):
    """Release a lock held by the calling tasklet.
    You can't release a lock you don't have.
    You can't remove a lock request that is enqueued.
    """
    lock_manager_channel.send((lck, None, caller))
 
def lock_manager():
    """Manage lock requests via a monitor task."""
    while queue or not stopManager:
        (lck, channel, caller) = lock_manager_channel.receive()
        if channel != None:
            # lock request
            if not locks.has_key(lck):
                # no lock held
                locks[lck] = caller
                # signal the requester
                channel.send(None)
            elif locks[lck] == caller:
                # reentrant lock
                channel.send(None)
            else:
                # append the request and block until lock released
                if queue.has_key(lck):
                    queue[lck].append((channel, caller))
                else:
                    queue[lck] = [(channel, caller)]
        else:
            # lock release
            if locks.has_key(lck) and locks[lck] == caller:
                # release the lock
                # get the next caller
                if queue.has_key(lck):
                    (channel, next_caller) = queue[lck].pop(0)
                    # remove empty wait queue                
                    if not len(queue[lck]):
                        del queue[lck]
                    # lock on the behalf of the requester
                    locks[lck] = next_caller
                    # notify the blocked requester
                    channel.send(None)
                else:
                    # remove the lock
                    del locks[lck]
            else:
                # no work needed to be done
 
                logger.debug(”locks.has_key(” + str(lck) + “) ” + str(locks.has_key(lck)))
        stackless.schedule()

(more…)

My wife decided to tame a spirit beast in Warcraft last night. Of course, at 9pm, even on a relatively dead server, she won’t find one and didn’t expect to: this was mostly a chance to scout out the locations where they spawn. This morning she was woken up at 4am, logged into Warcraft, and Gondria was waiting for her.

I’m afraid to roll against her in any dungeon groups.

Recent versions of Mozilla Firefox use SQLite to store the history and bookmarks. Ever wanted to get at the database instead of using the JSON backup file?
(more…)

I received my Kindle 2 yesterday. Becky liked how lightweight it was, but she prefers the button layout of the Kindle 1 — at the least, she’d like a previous button on the right side, and she liked having the SD card slot to store more books. The refresh rate and quality of the screen was higher, but she decided she’ll stick with her year-old one.

I had trouble finding a lot of long tail books. Feel free to request them for the Kindle: Amazon pays attention to these requests and will bring them to the publishers. Here are some of the titles I’ve requested already:

• The Lord of the Rings: 50th Anniversary, One Vol. Edition
• Sundiver (The Uplift Saga, Book 1)
• Earthclan ~ Startide Rising and The Uplift War
• Brightness Reef (The Uplift Trilogy, Book 1)
• Infinity’s Shore (The Uplift Saga, Book 2)
• Heaven’s Reach (The Second Uplift Trilogy #3)
• The Postman (Bantam Classics)
• Earth
• The Collected Stories of Arthur C. Clarke
• The Mote in God’s Eye
• The Gripping Hand
• Lucifer’s Hammer
• Heavy Weather
• The Forever War
• The Shockwave Rider
• Rainbows End
• Programming Collective Intelligence: Building Smart Web 2.0 Applications

As an Amazon employee, I learned this in orientation, in all-hands-meetings, and through doing my job. I’m impressed, however, that Scott Wingo of Seeking Alpha actually gets how Amazon does business.

Now, if only every other investor got it, I’d make a killing off stock sales.

Weak references allow object oriented software to maintain a reference to an object without preventing it from being garbage collected. They’re most frequently used in caching and mapping implementations and can provide significant savings when there is a high cost or latency involved in retrieving values from the database.

A weak reference map is an excellent pattern for ensuring a single object copy exists in memory at one time, as long as all requests to get objects go through the map first. This raises some development considerations:

• avoid multiple transactions operating on the same object or record — you don’t want to block transactions or have the state modified unexpectedly,
• you want to work with your weakly referenced objects through a repository layer which wraps get, put, and other persistence operations (ideally, you’ll work through a business object layer),/li>
• you may want to work with aspects as these can transparently offer transactional locking on object or record modifiers, and
• with effective management of a weak reference pool, you can identify leaks (unreleased objects).

In cloud applications, you can reduce calls to the backing persistent repository. In systems like S3, this reduces your traffic between your application and database which can help lower costs. Again, this provides the most benefit to persistent services rather than applications that use a servlets or short-lived transactions.
(more…)

Wrath of the Lich King is shipping. We’ve got two Collector’s Editions coming tomorrow (did I really pay $24 more for a frost wyrm pet?) and they were sent via FedEx, so they might arrive before the normal 6:30pm UPS delivery time.

I’m not taking time off work unlike a co-worker, and I’m not really anticipating being able to play WoW tomorrow at all. Last night’s plans of fetching some Dark Iron Ale Mugs for the Darkmoon Faire fell through when the servers were down for emergency maintenance until nearly 10pm. I don’t have a lot of faith in the WotLK launch at this time. I might spend the time looking at art books: World of Warcraft: The Art of The Trading Card Game) is great, while I wasn’t quite as pleased with The Art of World of Warcraft even though it did have concepts and art that are only now making it into the live game (like Northrend) and some that still haven’t (the Emerald Dream).