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…

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.


# 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()


I could have looked for the caller on the stack to lock/unlock the mutex, but I decided an arbitrary key was a better choice. In practice, the keys and locks should be strings (or other values that can be hashed into a dictionary), so passing object references isn’t a great idea.

Usage:

# within the context of a stackless task . . .
lock.acquire("myMethod", "myLock")
# do some stuff
lock.release("myMethod", "myLock")


Edit:
Signal is a class which is used to indicate that a signal has been thrown, in this case that the loop should be stopped.


class Signal():
    def __init__(self):
        self.flagged = False
 
    def flag(self):
        self.flagged = True
 
    def isFlagged(self):
        return self.flagged
 
    def __nonzero__(self):
        return self.flagged
 
    def __str__(self):
        return str(self.flagged)


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

1. Shut down Firefox.
2. Copy places.sqlite from your profile.
3. Start SQLite:
   
   $ sqlite3 places.sqlite
4. Review the sqlite3 manpage
5. Execute fun queries like examining your browse history:
   
   select a.url, a.title, b.visit_date from moz_places as a join moz_historyvisits b on a.id = b.place_id order by b.visit_date asc
6. Do nifty stuff like dump your query results to a file:
   
   .output myplaces.txt
7. Use awk to break your output file into a tab delimited format, import into Excel, and go wild with analysis

Bonus: figure out what your kids, co-workers, or employees have been browsing, assuming they’re not clueful enough to clean up after themselves.

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

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

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.

Implementation Notes
In Python:

• One weak reference cache is kept per database or type
• Weak references are kept in a dictionary, keyed on the same key as the database, the value being the weakref instance
• Implement a sweeper thread to walk the cache at regular, short intervals (250ms) to clear the cache of dead references

The Python weakref type is used this way:

# some object created from the database is called 'value'
# create a weakref
ref = weakref.ref(value)
 
# get the value back from a weakref
value = ref.__call__()
 
# value will be set to None if there are no strong references to the value object


Using weakrefs with dictionaries:

def stash(self, key, value):
    # store the weak reference in the refMap
    ref = weakref.ref(value)
    refMap[key] = value
 
def get(self, key):
    # retrieve the weak reference from the refMap
    value = None
 
    try:
        ref = self.refMap[key]
        value = ref.__call__()
    except KeyError:
        pass
 
    if value == None:
        self.lock.acquire()
        try:
            value = self.repository.get(key)
 
            # cache the value
            self.stash(key, value)
        except KeyError, e:
            self.logger.warning(”Key not found in repository: ” + str(e))
            raise
        finally:
            self.lock.release()
 
    return value


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).