Quick And Dirty Job Queue

I’ve been a busy developer for the last little while. I’ve put out a game analytics stack that (AFAIK) rivals the features of every commercially available solution in the gaming space. Along the way I’ve been trying to follow an agile development approach of rapid development and deployment, and make sure that the features get out in front of the stakeholders as they are completed.

Of course, that means that the path to get here hasn’t necessarily been terribly smooth, and it’s been filled with a great many late nights. A lot of those late nights and weekends have been centered around making development deadlines, but almost all of the really late nights have been for deployments or devops purposes.  Which brings me to the focus of why I’m writing this blog post.

One of the things I do for a living is throw data around.  Not just data, but lots of data – and lots of kinds of data too.  The data warehouse part of the analytics stack is complicated and there’s lots of runners pushing data all over the place.  Believe it or not, cron has actually been sufficient so far for our job scheduling needs.  At some point I expect that I’ll have to move to something like Oozie – or maybe just skip it entirely and head straight for the Storm (this seems more my speed anyway).

Over time, I’ve added features like parallel importing, parallel summaries, more summaries, and so so much more.  One of the ongoing (many) battles I’ve been facing is the memory footprint of unique and percentile calculations.  Combining breakneck feature development with billions of events and millions in row cardinality has driven the deployments to be multi day affairs and devops to take up an increasingly large amount of my time.

With that in mind, I’d like to impart to you a cool quick and dirty job queue manager.  For my particular purposes it lets my batch processing platform operate quite a bit like a data stream or message passing processor – without overloading the (meager) processing resources available.  First, let me state that I have long been a fan of xargs and it makes a daily appearance in my shell.  However, it has several critical failings for this purpose:

• Untrapped application deaths can “permanently” lower your processing throughput rate
• You can’t add tasks to the input list once things are underway
• You can’t remove tasks from the input list once things are underway
• It doesn’t realistically scale into crontab

With these limitations in mind, I set out to find a way to improve my current crontab based solution in some key areas:

• We must not overload the processing resources by firing off too many processes
• The processes must restart quickly when data is available to be processed
• I don’t want to hear about it when a process fails because there’s nothing to do (flock based solutions)
• I do want to hear about it when there’s error output to be had
• Ideally, this would scale across machines on the cloud

A crontab styled on the following was the outcome of my search – and it fulfills all the requirements.  The magic happens in several parts.  First, the command “sem” is an alias for (GNU) parallel –semaphore.  It’s not available on ubuntu (coreutils/moreutils parallel is different), so you’ll need to install it manually (see below).  Let’s examine this part of the command: “sem –id proc -j2 ImportProcess”.  This checks the “proc” counting semaphore and fires off a non-blocking ImportProcess if there are less than two objects using that semaphore.  If there are 2+, it will block.

At a glance, that’s exactly what I want.  It won’t run if there’s already N of them running, but it will just sit there.  The requests will pile up and slow everything down.  I looked at the arguments available in parallel and sem naturally, but none of them seemed to do what I want.  sem –timeout claims to simply force-fire the process after a time and parallel –timeout kills the process if it’s still running after a certain amount of time.  What I wanted was to have the process only wait for the mutex for so long.

My first thought was that I could use timeout to accomplish this, but as it turns out parallel ignores SIGTERM and continues to wait.  However, timelimit -qs9 sends a kill -9 to the blocking sem request.  It’s ugly, but effective and works.  The final piece of the puzzle would be to swallow the death of timelimit.  That’s where “|| true” comes in.  As with all things, there’s a limit to how cool this particular piece of code is – I also lose notications of the OS killing my application (for example, it runs out of memory).  I’ll work on that later, probably by adding a patch to parallel’s many, many, many, many options.

MAILTO=your_email@your_domain.com
*/1 * * * * timelimit -qs9 -t1 /usr/local/bin/sem --id proc -j2 ImportProcess || true
*/1 * * * * timelimit -qs9 -t1 /usr/local/bin/sem --id proc -j5 TransformProcess || true
*/1 * * * * timelimit -qs9 -t1 /usr/local/bin/sem --id proc -j7 SummaryProcess || true

Installing GNU Parallel:

wget http://ftp.gnu.org/gnu/parallel/parallel-20130222.tar.bz2
tar jxf parallel-20130222.tar.bz2
cd parallel-20130222/
./configure
make
sudo make install
which parallel # Make sure this says /usr/local/bin instead of /usr/bin

Filed under: Data Warehousing, Software Development

Primitive Class Variables in Python

I recently ran across something peculiar in my Python development.  I was writing some builders for complex JSON objects and decided to move away from random.randint and simply use a class variable.  I had some code that looked something like this:

class FooBuilder(object):
    def __init__(self, **kwargs):
        options = {
            "obj_id" : random.randint(1, 10000000),
        }

        options.update(kwargs)

I know, it’s not a great design and I could expect some failures due to random number collisions. It was also a bit slower than I really wanted, so I modified it to look like this:

class FooBuilder(object):
    next_obj_id = 0
    def __init__(self, **kwargs):
        options = {
            "obj_id" : self.next_obj_id,
        }

        options.update(kwargs)    
        self.next_obj_id += 1

However, it had a peculiar property: all my tests failed because it appeared that the class variable never updated. I did some experimenting and found lists, dictionaries, and pretty much everything but ‘native’ types worked exactly as expected. It turns out that what’s happening is that you’re assigning the incremented primitive int to the instance because it’s literally a new object. In order to assign it back to the class you have to take some special precautions – type(self).next_obj_id += 1. Here’s some sample code that demonstrates what I’m talking about:

import random

class Foo(object):
    def __init__(self, **kwargs):
        options = {
            "obj_id" : random.randint(1, 10000)
        }

        self.data = options
        print "Foo." + str(self.data)

class Bar(object):
    next_obj_id = 0

    def __init__(self, **kwargs):
        options = {
            "obj_id" : self.next_obj_id
        }

        self.next_obj_id += 1

        self.data = options
        print "Bar." + str(self.data)

class Working(object):
    next_obj_id = 0

    def __init__(self, **kwargs):
        options = {
            "obj_id" : self.next_obj_id
        }

        type(self).next_obj_id += 1

        self.data = options
        print "Working." + str(self.data)

Foo()
Foo()
Foo()

Bar()
Bar()
Bar()

Working()
Working()
Working()

It outputs:

Foo.{‘obj_id’: 1234}
Foo.{‘obj_id’: 40}
Foo.{‘obj_id’: 2770}
Bar.{‘obj_id’: 0}
Bar.{‘obj_id’: 0}
Bar.{‘obj_id’: 0}
Working.{‘obj_id’: 0}
Working.{‘obj_id’: 1}
Working.{‘obj_id’: 2}

tl;dr:
type(self).class_variable_name or self.__class__.class_variable_name to modify class variables seems to be a better choice than self.class_variable.

Filed under: Software Development, Python, Software Development

Pessimistic vs Optimistic Memoization

def memoize(obj):
    cache = obj.cache = {}

    @functools.wraps(obj)
    def memoizer(*args, **kwargs):
        if args not in cache:
            cache[args] = obj(*args, **kwargs)
        return cache[args]
    return memoizer

I think one of the first things that anyone does with a dynamic language is write a memoizer to save time on expensive calculations. This is the memoizer from http://wiki.python.org/moin/PythonDecoratorLibrary. I like this one because it exposes the cache for clearing – an important feature in tests. This can be accomplished by creating a list of memoized functions and manually resetting their cache. The actual cache reset looks something like this:

@memoize
def method_name(some_arg):
    return some_arg + 1

method_name.cache = {}

However, I think there’s several things we should know about this particular decorator before just using it:

• It does not properly account for **kwargs. The thing to remember here is that **kwargs is implicitly a dictionary – an unhashable object. There are several popular methods of hashing a dictionary, but the far and away most popular appears to be hashing on frozenset(dict.items()). Another much less popular way is tuple(zip(dict)). We’ll do some testing to determine which is superior. One important thing to remember here is that large amounts of kwargs and long variable names can lead to quite a performance penalty no matter which one is ultimately better.
• It does not properly handle unhashable or nested arguments. I think this is probably an acceptable limitation because solving it imposes a large penalty on both code performance and code maintainability. I think it is imperative to have a proper test suite to ensure that @memoized methods are not passed unhashable or nested arguments.
• There appears to be two competing ways to do caching in Python. The first is the Look Before You Leap approach that conventional wisdom dictates, and is the one used here. Some cursory thought on the matter tells me that a more optimistic method of handling cache hits with try/except might work better. We’ll do some testing to determine which is superior.

Each caching strategy was tested over a list of 1 million tuples and utilize kwargs.  The numbers in the legend represent the basic cardinality of the unique values in the tested list.  The cache hit rate can be found by dividing the cardinality by 1 million.  Each memoization strategy was tested 20 times and the test results here are the average. I think that a picture is worth a thouand words, and so I’ve included a pretty graph. However, I’ve also included the base data below.

I think there should be several take aways from this:

• tuple(zip(dict)) is superior to frozenset(dict.items())
• Optimistic caching (try/except) is generally superior Look Before You Leap (key in cache)
• There is a noticeable performance penalty for caching on kwargs. It might be worth having several memoize annotations and using the most appropriate one.
• Lots of **kwargs with long names causes a major performance penalty

This is the final version of the memoizer (many thanks to Bryce Drennan in the comments for catching a bug in the memoizer):

def memoize(obj):
    cache = obj.cache = {}

    @functools.wraps(obj)
    def memoizer(*args, **kwargs):
        key = (args, tuple(zip(kwargs.iteritems())))
        try:
            return cache[key]
        except KeyError, e:
            value = obj(*args, **kwargs)
            cache[key] = value
            return value
    return memoizer

This is the previous version of the memoizer:

def memoize(obj):
    cache = obj.cache = {}

    @functools.wraps(obj)
    def memoizer(*args, **kwargs):
        key = (args, tuple(zip(kwargs)))
        try:
            return cache[key]
        except KeyError, e:
            cache[key] = value = obj(*args, **kwargs)
            return value
    return memoizer

Raw data

Tiny (Iterations: 1000000, Cardinality: 100)

• Reference : 1.2129
• Set : 3.8267
• Zip : 3.0283
• Pessimistic : 3.0055
• Optimistic : 2.4478
• No kwargs Reference : 0.5133
• No kwargs Pessimistic : 1.1473
• No kwargs Optimistic : 0.9309

Low (Iterations: 1000000, Cardinality: 10000)

• Reference : 1.3167
• Set : 4.5701
• Zip : 3.4687
• Pessimistic : 3.5359
• Optimistic : 2.9393
• No kwargs Reference : 0.6553
• No kwargs Pessimistic : 1.3239
• No kwargs Optimistic : 1.1201

Med (Iterations: 1000000, Cardinality: 99995)

• Reference : 1.6757
• Set : 4.9049
• Zip : 3.8719
• Pessimistic : 3.8955
• Optimistic : 3.2962
• No kwargs Reference : 0.9838
• No kwargs Pessimistic : 1.7194
• No kwargs Optimistic : 1.5371

Filed under: Software Development, Decorator, Memoize, Python

Finding Unused Functions in a Python Source Tree

So for the last few months I have been crunching up a storm on getting the analytics out the door for our latest game.  I just finished some cool new features and had to do some major refactors (one step at a time, of course).  I began to suspect that I’d left some stray code hanging out there that wasn’t being used anymore.  I figured a great way to solve the problem was by looking at each function and grepping the source tree to see if it existed anywhere else.  First, let me introduce you to ack-grep [betterthangrep.com] (aliased as ‘ack’ below).  The best thing about ack-grep is that it lets you filter out certain file types from your results – and despite being written in Perl it’s frequently much faster than grep.

Now I’ll go over the evolution of a shell command.  Some of the steps are injected here because I knew where I was going – but for your benefit I’ll explain how things evolved.  The code base in question is about 10k lines over 140 files.

$ ack ‘def’

… bunch of functions and a bunch of other stuff …

$ ack ‘ def ‘

… function definitions …

Now let’s get the function name itself.  It should look like ‘def “function name”(arguments):’ so the first order of business is to cook up a regular expression to filter the line.  I’m better with Perl than with Sed, so I did it like this:

$ ack ‘def ‘ | perl -pe ‘s/.*def (\w+)\(.*/\1/’

I scrolled through looking for any obvious errors but didn’t find any.  Now comes the magic sauce.  xargs -I{} creates a new command for every input line and inserts the input row where {} exists.  Basically, this created a for each loop in shell.

$ ack ‘def ‘ | perl -pe ‘s/.*def (\w+)\(.*/\1/’ | xargs -I{} bash -c ‘ack “{}”‘

One thing I saw was that function usages were being attributed to functions that *contained* their name.

$ ack ‘def ‘ | perl -pe ‘s/.*def (\w+)\(.*/\1/’ | xargs -I{} bash -c ‘ack “\b{}\b”‘

That’s better, but functions that are defined multiple times (like __init__) are coming up a lot…

 $ ack ‘def ‘ | perl -pe ‘s/.*def (\w+)\(.*/\1/’ | sort | uniq | xargs -I{} bash -c ‘ack “\b{}\b”‘

Ok, but now the text is just flying by so fast and some functions are used hundreds of times and others very few…

$ ack ‘def ‘ | perl -pe ‘s/.*def (\w+)\(.*/\1/’ | sort | uniq | xargs -I{} bash -c ‘ack “\b{}\b” | wc -l’

Ok, now I know how many times something appears but not what it is…

$ ack ‘def ‘ | perl -pe ‘s/.*def (\w+)\(.*/\1/’ | sort | uniq | xargs -I{} bash -c ‘echo {} && ack “\b{}\b” | wc -l’

Ok, that’s great.  Now I have the name of the function and how many times that name appears in the source tree.  It’s kinda unwieldy though because the name is on a different line than the count and I can’t use grep.

$ ack ‘def ‘ | perl -pe ‘s/.*def (\w+)\(.*/\1/’ | sort | uniq | xargs -I{} bash -c ‘echo -n {} && ack “\b{}\b” | wc -l’

Fantastic.  Now I can look at just the functions that rarely get used!  Oh look, there’s so many tests coming up… :-/

$ ack ‘def ‘ | perl -pe ‘s/.*def (\w+)\(.*/\1/’ | sort | uniq | xargs -I{} bash -c ‘echo -n {} && ack “\b{}\b” | wc -l’ | egrep -v ‘^test_’

Ok, now let’s limit it to things appearing once…

$ ack ‘def ‘ | perl -pe ‘s/.*def (\w+)\(.*/\1/’ | sort | uniq | xargs -I{} bash -c ‘echo -n {} && ack “\b{}\b” | wc -l’ | egrep -v ‘^test_’ | egrep ‘ 1$’

Fantastic.  That’s exactly what I was looking for.

Filed under: Software Development, bash, Python, software develpment

Python JSON Performance

So I’ve been pretty open about the fact that I’ve moved from data warehousing in the television and online ad industries to data warehousing in the gaming industry. The problem domains are so incredibly different. In the television and ad industries, there’s a relatively small amount of data that people are actually concerned about. Generally speaking, those industries are most interested in how many people saw something (viewed the ad), how many people interacted with it (clicked on it), and whether they went on to perform some other action (like buying a product).

However, in the gaming industry we’re interested in literally everything that a user does – and not in the creepy way. The primary goals are to monitor and improve user engagement, user enjoyment, and core business KPIs.  There are a lot of specific points to focus on and try to gather this information, and right now the industry standard appears to be a highly generalized event/payload system.

When looking at highly successful games like Temple Run (7M DAU [gamesbrief]) it’s only 150 events per user to get a billion events per day.  Between user segmentation and calculating different metrics it’s pretty easy to see why you’d have to process parts of the data enough times that you’re processing trillions of events and hundreds of GB of facts per day.

When I see something that looks that outrageous, I tend to ask myself whether that’s really the problem to be solving. The obvious answer is to gather less data but that’s exactly the opposite of what’s really needed. So is there a way that to get the needed answers without processing trillions of events per day? Yes I’d say that there is; but perhaps not with the highly generic uncorrelated event/payload system.  Any move in that direction would be moving off into technically uncharted territory – though not wholly uncharted for me. I’ve built a similar system before in another industry, albeit with much simpler data.

If you aren’t familiar at all with data warehousing, a ten thousand foot overview (slightly adapted for use in gaming) would look something like this.  First, the gaming client determines what are interesting facts to collect about user behavior and game performance. Then it transmit JSON events back to a server for logging and processing.  From there the data is generally batch processed and uploaded to a database* for viewing.

So as a basic sanity check, I’m doing some load testing to determine whether it is feasible to gather and process much higher resolution information about a massively successful game and it’s users than seems to be currently available in the industry.  Without going into proprietary details, I’ve manufactured analytics for a fake totalhelldeath game.  It marries Temple Run’s peak performance with a complicated economy resembling Eve Online’s.

From there, I’m compressing days of playtime into minutes and expanding the user base to be everyone with a registered credit card in the app store (~400M people as of 2012) [wikipedia].  The goal here is to see how far it’s possible to reasonably push an analytics platform in terms of metrics collection, processing, and reporting.  My best estimate for the amount of data to be processed per day in this load test is ~365 GB/day of uncompressed JSON.  While there’s still a lot that’s up in the air about this, I can share how dramatically the design requirements differ:

Previously:

• Reporting Platform: Custom reporting layer querying 12TB PostgreSQL reporting databases
• Hardware: Bare metal processing cluster with bare metal databases
• Input Data: ~51GB/day uncompressed binary (~150TB total uncompressed data store)
• Processing throughput: 86.4 billion facts/day across 40 cores (1M facts/sec)

Analytics Load Test:

• Reporting Platform: Reporting databases with generic reporting tool
• Hardware: Amazon Instances
• Input Data: ~365 GB/day uncompressed JSON (~40k per “hell fact” – detailed below)
• Processing throughput: duplication factor * 8.5M facts/game day (100 * duplication facts/sec)

I’ve traditionally worked in a small team on products that have been established for years.  I have to admit that it’s a very different experience to be tasked with building literally everything from the ground up – from largely deciding what analytics points are reasonable to collect to building the system to extract and process it all. Furthermore, I don’t have years to put a perfect system into place, and I’m only one guy trying to one up the work of an entire industry.  The speed that I can develop at is critical: so maintaining Agile practices [wikipedia], successful iterations [wikipedia], and even the language I choose to develop in is of critical importance.

The primary motivator for my language choice was a combination of how quickly I can crank out high quality code and how well that code will perform.  Thus, my earlier blog post [blog] on language performance played a pretty significant role in which languages saw a prototype.  Python (and pypy specifically) seems well suited for the job and it’s the direction I’m moving forward with.  For now I’m building the simplest thing that could possibly work and hoping that the Pypy JIT will alleviate any immediate performance shortfalls.  And while I know that a JIT is basically a black box and you can’t guarantee performance, the problem space showed high suitability to JIT in the prototyping phase.  I foresee absolutely no problems handling the analytics for a 1M DAU game with Python – certainly not at the data resolution the industry is currently collecting.

But, I’m always on the look out for obvious performance bottlenecks.  That’s why I noticed something peculiar when I was building out some sample data a couple of days ago. On the previous project I worked on, I found that gzipping the output files in memory before writing to disk actually provided a large performance benefit because it wrote 10x less data to disk.  This shifted our application from being IO bound to being CPU bound and increased the throughput by several hundred percent.  I expected this to be even more true in a system attempting to process ~365GB of JSON per day, so I was quite surprised to find that enabling in-memory gzip cut overall application performance in half.  The implication here is that the application is already CPU bound.

It didn’t take much time before I’d narrowed down the primary culprit: json serialization in pypy was just painfully slow. It was a little bit surprising considering this page [pypy.org] cites pypy’s superior json performance over cpython.  Pypy is still a net win despite the poor JSON serialization performance, but the win isn’t nearly as big as I’d like it to be. So after a bit of research I found several json libraries to test and had several ideas for how the project was going to fall out from here:

• Use a different json library. Ideally it JITs better than built in and I can just keep going.
• Accept pypy’s slow json serialization as a cost of (much) faster aggregation.
• Accept cpython’s slower aggregation and optimize aggregation with Cython or a C extension later
• Abandon JSON altogether and go with a different object serialization method (protobuf? xdr?)

After some consideration, I ruled out the idea of abandoning JSON altogether. By using JSON, I’m (potentially) able to import individual records at any level into a Mongo cluster and perform ad hoc queries. This is a very non-trivial benefit to just throw away! I looked at trying many JSON libraries, but ultimately settled on these three for various reasons (mostly relating to them working):

• builtin json
• simplejson
• ujson (Incompatible with pypy)

To test each of these libraries, I devised a simple test with the goal of having the modules serialize mock event data.  This is important because many benchmarks I’ve seen are built around very small contrived json structures.  I came up with the following devious plan in order to make sure that my code couldn’t really muck up the benhmark results:

• create JSON encodable dummy totalhelldeath fact list
• foreach module: dump list to file (module.dump(facts, fp))
• foreach module: read list from file (facts = module.load(fp))

Just so that everything is immediately obvious: this was run on one core of an Amazon XL instance, and the charts are measuring facts serialized per second.  That means that bigger bars are better here.

Read Performance

There’s really no obvious stand out winner here, but it’s obvious that the builtin json library is lacking in both cpython and pypy. It obviously runs a bit faster with cpython, but it’s not enough to really write home about. However, simplejson and ujson really show that their performance is worth it. In my not-so-expert opinion, I’d say that ujson walks away with a slight victory here.

Write Performance

However, here there is an obvious standout winner. And in fact, the margin of victory is so large that I feel I’d be remiss if I didn’t say I checked file sizes to ensure it was actually serializing what I thought it was! There was a smallish file size difference (~8%), primarily coming from the fact that ujson serializes compact by default.

So now I’m left with a conundrum: ujson performance is mighty swell, and that can directly translate to dollars saved.  In this totalhelldeath situation, I could be sacrificing as much as 71k + 44k extra core-seconds per day by choosing Pypy over CPython.  In relative money terms, that means it effectively increases the cost of an Amazon XL instance by a third.  In absolute terms, it costs somewhere between $5.50 USD/day and $16 USD/day – depending on whether or not it’s necessary to spin up an extra instance or not.

Obviously food for thought. Obviously this load test isn’t going to finish by itself, so I’m putting Python’s (lack of) JSON performance behind me.  But the stand out performance from ujson’s write speed does mean that I’m going to be paying a lot closer attention to whether or not I should be pushing towards CPython, Cython, and Numpy instead of Pypy.  In the end I may have no choice but to ditch Pypy altogether – something that would make me a sad panda indeed.

Filed under: Data Warehousing, Game Design, Personal Life, Software Development

CSM Minutes: Misleading

Let me begin with a quote from the CSM minutes:

CCP Greyscale moves on to explain his work on sentry guns. Sentry guns will now shoot anyone with a criminal flag, suspect or otherwise. Sentry guns will also start with smaller amounts of damage, and ramp up with time. Ideal tuning will be to where triage carriers will die at around 4 1/2 minutes. This way, if you want to use triage carriers in lowsec on gates you can, but you must commit to the cycle for a length of time before starting your reps, if you want to deactivate triage before the sentry guns kill you and jump out. CCP Greyscale also points out that another goal is to make it so that the first couple of hits won’t kill an interceptor immediately, enabling a quick tackle, and then a warp out.

Aleks remarks that this would be great for enabling more frigate use in lowsec piracy.
Aleks asks when all of these changes will be released, and when there will be dev blogs released for this information.
CCP Masterplan explains that this is where everything is at in the design process, that they’re looking forward to working more on this as the Inferno stuff dies down.
CCP Soundwave: “It is looking like a December release.”
Aleks and CCP Greyscale briefly discuss community response to these changes, Greyscale acknowledges that the changes to “suspect” flagging would upset some players, particularly canflippers.

I want to be clear that presentation of this section of the CSM minutes is very different from this following section, which is clearly a brain storm:

On the subject of sniping, Greyscale tossed out a high-level idea for a fix to sniping. He asked for CSM input on one such idea, an interdiction probe that would be launched a certain range before the bubble would deploy. In essence it would work as a drag-bubble to protect the sniping fleet, or at least give it ample time to react and reposition.
Elise was receptive to the idea and added that the biggest hindrance to sniping is the speed of ongrid probing.
Seleene and UAxDEATH agreed strongly.
CCP Soundwave chimed in with an idea of putting probes on grid and making them destructible. He argued that it would give small support a more pronounced role.
UAxDEATH was very receptive to the idea of giving support a stronger role.
Two step spitballed some ideas where probing would become less accurate with more results, and another idea where there was a probe-killing-probe.

The rage was further fanned on by certain CSM members who seemed to be all but directly confirming that it was already in development and would be hitting TQ in a form very like it was presented in the CSM minutes.   The problem got worse when many other CSM members refused to clarify that section of the minutes or actively defended it.  There were many suggestions by both the CSM and CCP to post on the forums - because obviously this is a good place to hold a discussion.  The only official answer was “It isn’t final until it’s on TQ”, a phrase that’s preceded a great many things that have in fact made their way to TQ.  It truly surprises me that the CSM feels that the community “jumped the shark” and was unreasonably angry given the presentation we were given about what was said.

However, after much discussion with various CSM members via blog post comments, forum posts, twitter, and Skype… I have to say that I’m pretty sure that the CSM minutes probably did not reflect the spirit of what was said at the CSM summit.  Both Hans Jagerblitzen and Seleene specifically said they’d not support any changes with ramifications so broadly destructive to PVP in low sec.  Hans even went back and watched the video and says that the context surrounding the fact it was brain storming was simply not put in the CSM minutes.

And as a final recap, here is a sample of the enormous list of problems with what was represented in the CSM minutes:

• Gate camping is a hallmark of PVP in Eve because travel chokepoints are where you are going to find people.  This is true in high sec, low sec, null sec, and WH space.  Why should low sec suddenly become very different without core game mechanics changes that support that change across all of Eve?
• Any sentry fire that was heavy enough to kill triage carriers at 4.5 minutes would be dealing somewhere between 35k and 150k DPS – obviously much more than any subcap can work around.  This means that the overall implication is that most non-gank subcap fights would also end up with everyone just getting blapped by the sentries.  Gate camping and ganks would still be possible via ninja camping and sniping, but real PVP fights would simply become untenable to have on a low sec gate.
• The suggestion allows for gate camping with triple sensor boosted stilettos.  While it won’t materially change my own travel through low sec, this would make travel for non-flashy people much more dangerous – ostensibly something that we’re trying to avoid.
• The suggestion does nothing for the core reasons why low sec is an underutilized area of space.  Provably, gate camps were never the problem – after all, we can look to null sec with it’s perma bubble camps to know better.  It’s must be a risk vs reward thing.

So obviously the suggestion itself is not fully thought out because of it’s ramifications for PVP in low sec, so let’s come up with something that sounds reasonable.  From everything I can gather, these are the primary motivations:

• Get more people in to low sec
• Allow different kinds of engagements on gates (eg, frigates)
• Prevent perma camps
• Prevent capital camps
• Prevent orca camps?
• Prevent blob camps?

For the sake of full disclosure, here’s what I personally think of each:

• More people in low sec is great, but I don’t care so much about carebears coming to low sec.  They will never leave the relative safety of High and Null sec for the much more dangerous waters of Low sec – and that’s perfectly fine.  Give me your casual and small gang PVPers instead – all of them you can round up.
• I’m kinda -1 to letting frigs engage under sentry fire.  On the one hand it’d be cool, but on the other it makes travel through low sec much more dangerous for carebears.
• While I don’t tend to gate camp (it’s boring), I see absolutely no problem with perma camps.  I feel like places like Amamake and Rancer provide interesting geography and places of legend.  I see this as literally no different than the perpetual camps in PF- and M-O and other null sec entry systems.
• I see absolutely no problem with capital camps.  I feel like low sec tends to small gang PVP and dropping a triage carrier or two is a pretty big signal there’s about to be an epic fight.  Well, it would be if you weren’t about to have PL drop a few hundred supercaps on you anyway.
• Yeah, nerf the shit out of Orca/Carrier stowing under aggression.
• I’m not a big fan of blob camping, but it’s allowed in every other area of space.  I see no reason why it shouldn’t be allowed in low sec too.

If the goal is to allow more types of PVP in low sec, I’d say that the first thing that should be done is just remove sentries entirely.  The key distinction between NPC null sec and Low sec would be the lack of bubbles, bombs, and certain supercapital features.  It’d mean that people no longer hesitated to pull the trigger on who would aggress because there would be no sentry fire to worry about.  There are a number of really good things about this approach – however it’d also kill the “heavier ship” fighting style that only blooms in low sec.

If the goal is to get more carebears into low sec, I think we’re looking entirely in the wrong direction.  The simple fact of the matter is that anyone that can stomach any risk at all is already in null sec – where the best rewards are.  There’s no reason for anyone to go to low sec for carebear rewards, ever.  So the first thing to do would be to provide that.  Then we should keep sentry guns or perhaps buff them a bit (with the added “benefit” of further encouraging the heavier ship doctrines I mentioned earlier).  Even if we neglected the fact that most established pirate corps have dozens of max skill scan prober alts, the instalocking frigs would simply be the doom of high sec carebears coming to low sec for PVE.

If the goal is to nerf Orca/Carrier stowing, then simply prevent stowing when you could not jump through a gate (eg, you are aggressed).  You could also transfer aggression to the Orca.

If the goal is to nerf capital camps and encourage frigate PVP under gate fire, I’d say the right answer is to turn sentry guns into missile batteries firing relatively slow missiles.  This means that you can scale damage by sig radius and speed, so capitals are getting hit by a dread while frigs and fast cruisers are getting tickled.  I hesitate to point it out, but it could also be used as a mechanism for ramping up the damage and would provide a visual indicator of how angry the sentry guns are becoming - warp out or die when this Ball O Rage hits you.

One thing I know for sure is that I am not a game designer and don’t really want to be one.  But, I will do everything in my power to help the game move in a direction that’s a bit more friendly to everyone without simply deleting my play style.

Filed under: Eve, Gaming

Calling the CSM to Account

So recently the CSM spent a great deal of time discussing their role and how important they are to CCP as a reality check/sounding board. I use the term “recently” a bit loosely, mind you – it’s been months since the CSM met with CCP, but only just now have the minutes come out. Inside those minutes, on pages 93-96 or so is some interesting information about CCP’s plans for gate guns in low sec:

Present: CCP Masterplan, CCP Greyscale, CCP Unifex, CCP Explorer, CCP Punkturis, CCP Tallest, CCP
Tuxford, Alekseyev Karrde (Lync), Hans Jagerblitzen (Lync)

…

CCP Greyscale moves on to explain his work on sentry guns. Sentry guns willnow shoot anyone with a criminal flag, suspect or otherwise. Sentry guns will also start with smaller amounts of damage, and ramp up with time. Ideal tuning will be to where triage carriers will die at around 4 1/2 minutes. This way, if you want to use triage carriers in lowsec on gates you can, but you must commit to the cycle for a length of time before starting your reps, if you want to deactivate triage before the sentry guns kill you and jump out. CCP Greyscale also points out that another goal is to make it so that the first couple of hits won’t kill an interceptor immediately, enabling a quick tackle, and then a warp out.

Aleks remarks that this would be great for enabling more frigate use in lowsec piracy. Aleks asks when all of these changes will be released, and when there will be dev blogs released for
this information.
CCP Masterplan explains that this is where everything is at in the design process, that they’re looking forward to working more on this as the Inferno stuff dies down.
CCP Soundwave: “It is looking like a December release.”
Aleks and CCP Greyscale briefly discuss community response to these changes, Greyscale acknowledges that the changes to “suspect” flagging would upset some players, particularly canflippers.
…

There are several overall implications here:

• The first sentence describes this work as already being somewhere between in progress and finished.  Either way, these changes are expected to be complete and ship in December 2012.  CCP and the CSM have indicated that this is a miscommunication in the CSM minutes.  It was apparently not presented as it was presented in the CSM minutes – it was more of a brain storm session with much rabbit holing.
• Sentry guns will now shoot people with a criminal flag (GCC, sec status below -5) as well as people who are flagged as a suspect (can flipped, minor crimes of aggression).
• It will now be reasonable to run a 3x sensor boosted Stiletto on the gate for initial tackle with long range sniper tornados for killing the captured prey.  Solo travel through low sec will become much more dangerous.
  
• The goal of killing triage carriers (2-3M EHP, 25k DPS tank) at 4.5 minutes means that the scaling on sentry fire will average much higher than 25k DPS at 4.5 minutes.  Some basic exploration of the matter says that the sentry guns will be dealing somewhere between 60K-125k DPS depending on when the exponential scale starts to invoke (at 2.5 minutes and 4 minutes respectively).  Pretty much no matter how you slice it, at 4.5 minutes into a fight we’re going to be seeing super tanked subcaps blapped off the field by sentry fire.
• The net implication is that it’s a massive boost to gate camps and a massive nerf to actual fights on a gate.

The community is, of course, split over this:

• Carebears are trumpeting about how pirates have systematically killed low sec through over hunting and gate camping.  Why, it’s about time that CCP did something to push pirates into getting real fights in belts like they did back in 2003!
• Issler (CSM, ultra carebear who desires to eliminate PVP in Eve) is pointing out that gate camping has never been an allowed mechanic, which is why gate guns were first implemented.  They’re just fixing the bug that allowed pirates to gate camp in the first place.
• Gate Camping pirates don’t seem to care or are excited that they’ll now be able to tackle with a 3x SeBo’d Stiletto and snipe with Tornados.
• People who roam are crying bloody murder because virtually no fight of any size resolves within 4 minutes.
• Very few people have noticed that pirates are going to be shot for simply waiting on the gate, regardless of aggression status. This is wrong.

In response to the pure ignorance displayed by CCP Greyscale and the CSM, I have offered to sacrifice my main character (-10 sec status, 90M SP, pure Minmatar PVP spec) for the purpose of forcing CCP Greyscale to play a pirate for the next 6 months.  I will furthermore fund the account for this endeavor so that he can keep skill training with his 3 free (presumably industrial) accounts.  While it would be ideal if I were to get the character back, I would understand if it weren’t possible.  I feel that offering to sacrifice my 90M SP main, the name my friends know me as, and $100 USD of my own money is the most sincere way that I can express myself on this matter: CCP Greyscale cannot possibly have played the game as a pirate (or PVPer in general!) in recent memory.  I feel that his education is absolutely critical.

Now, while I am disappointed with CCP on the matter, I am even more disappointed with the CSM.  So it is at this point that I demand an accounting of the CSM.  They claim their job is to protect CCP from making boneheaded mistakes, yet not even one of them objected to these sentry changes.  Not even one of them had the foresight to understand the catastrophe that is going to happen to low sec.  Not even one of them realized that this is effectively deleting the entire pirate profession from the game.

So what gives, guys?  Why didn’t you object to deleting PVP real PVP from low sec?

Edit:

Clarification from Masterplan [1][2]has stated that pirates will NOT be blapped by gate guns without first having done “bad things”.  Furthermore, the suspect flag will probably not cause blapping.

Filed under: Eve, Gaming, CCP, CSM, Eve, PVP

Making ISK

I was responding to a post [eve-o] about L4 missioning and concluded with:

I typically ran with a Tengu/CNR/Golem combo in high sec and a Vargur in 0.0. Then I realized that level 4 missions are one of the worst ways to make ISK in Eve and stopped doing them.

Obviously, this lead to the natural question of just what I actually do for ISK.  And this was my answer [eve-o]:

If I had to scrape up some ISK quick, I’d do one of the following (in order):
- Sell some stock on the market. This is how I make the overwhelming majority of my ISK.
- C2 WH with a C2 static. I think I’d like to try this with a Kronos, but I know that Sleipnir + Noctis generally pulls in 100-150M/hr. This is where I make my “PVE ISK”.
- Low Sec FW. My bomber pilots are hands down the most profitable thing I’ve ever done. My peak ISK/hr over an 8 hour period was around 450M/hr and the price of Slicers is looking pretty good [hint, hint].
- Low sec L5s. I’ve done this in a solo PVP (triage fit!) Nidhoggur, but I think I’d like to try it in an actual mission fit with a marauder on the side. Solo Niddy pulled in ~100M/hr and I’m betting an actual mission fit + marauder could bump it to above 200M/hr.
- 0.0 L4s + High sec AFK L4s. I guess this was pulling in ~120-170M hr, depending on whether I got camped in 0.0. I was using a Vargur in 0.0 and an overtanked FOF Tengu in high sec.

Just to be clear, I make most of my ISK from the market. The goal here is to do what I want to do in Eve and not spend time hamstrung by a lack of ISK.

Also, I forgot that I spent several months training up a series of PI alts and still haven’t done anything with them. Invading a C1 WH for them would be a good plan too.

The thing about it is that I don’t currently have any hard and fast ways to prove what my income stream has been during any particular part of my career in Eve.  I used to, but time has worn away the information.  But, I feel like these are reasonable ballparks.

Filed under: Eve, Gaming, Eve, pve

Pypy, Groovy, and more

Let me preface this with the fact that I currently work at a Java shop on the Data Warehousing team and there’s always some people making noise about what our Java.Next() will be.  For a long time I was sure that Java.Next() returned “Groovy”, but it appears that Scala has fast growing fan base where I work.  My new team lead even went so far as to imply that getting anything past the Sr Staff Steering Committee that wasn’t written in Java or Scala was going to be impossible.  That’s quite the bold statement given we have no Scala and lots of Groovy in the code base currently!

So this made me go out looking for examples of Scala and soon enough was wading through Scala, Scheme, Lisp, Clojure, Ocaml, Haskell, and Erlang.  The core concepts behind the languages aren’t really new to me, but the syntax certainly was.  In a lot of ways, I’d say that even well written programs looked every bit as bad as the worst Perl Line Noise I’ve ever seen.  Jumping off the deep end like that had a pretty predictable result: I got absolutely nowhere.  Still, I studied them enough that my head was swimming and I was dreaming about lambda calculus and color blindness tests.

Somewhere along the way, I ran across a rosetta stone [wikipedia] when I found this question on Stack Overflow.  The first thing I noticed was that the algorithm used was extremely naive – but that’s ok because it wasn’t really the purpose of the question.  The author even specifically asked people not to change the way factors were calculated.  I’d answer him on Stack Overflow myself, but frankly this blog post delves far too much into discussion and I don’t want to start my SO career off with negative karma.

So I’m pretty familiar with C and Python, but Erland and Haskell are obviously almost wholly new to me.  I probably would have kept going if it weren’t for Pypy’s superior performance really catching my eye.  Then I began to dig into the question (as posed) and noticed he was calling range() instead of xrange() for a Python2.7 implementation.  Then I thought his Python wasn’t very Pythonic so I rewrote it to use List Comprehensions.

def factorCount (n):
    square = math.sqrt(n)
    isquare = int(square)
    offset = -1 if isquare == square else 0
    return offset + sum([ 2 for x in xrange(1, isquare+1) if n % x == 0 ])

This lead me to some surprising results:

Python3.2:

- His code: 1m1.468s
- With list comprehension: 1m13.966s

Python2.7:

- His code: 0m34.382s
- With xrange(): 0m30.881s
- With xrange() and list comprenesion: 0m32.628s

Pypy 1.8:

- His code: 0m5.451s
- With xrange(): 0m4.780s
- With xrange() and list comprehension: 0m3.127s

I wasn’t totally sure what to make of CPython’s poor handling of list comprehensions, and Pypy’s superior performance came as a total shock to me.  Last time I’d checked up on Pypy, I had thought it was a Python interpreter written in Python but once all the cards are on the table (including JIT), it appears to run quite a bit closer to the machine than even CPython does.  If I had to describe it to a total neophyte, I think I’d call it something closer to a Python compiler.

At any rate, during the course of the weekend I looked back at the Java/Groovy discussion from above.  If you’re familiar with it, you’ll know that Groovy is basically a superset of Java so you can run exactly the same Java code as Groovy.  So I wrote the totally expected Java implementation and ran it as Java.  Then I ran it as Groovy.  Then I def’ed all the variables and ran it as groovy again.  And then I got a wild hankering to do find out what the performance was like in Scala and Perl.

Anyway: here are the sorted results, including all optimization from the original discussion:

• Pypy 1.8 2.95 sec
• Haskell [GHC 7.4.1] 3.27 sec
• C [ gcc 4.6.3 ] 3.32 sec
• Scala 2.9.1 9.79 sec
• Java 1.6 15.77 sec
• Erlang 5.8.5 28.43 sec
• Python 2.7 31.79 sec
• Groovy 1.8 47.61 sec
• Perl 5.14 61.95 sec
• Java as Groovy 1.8 69.97 sec
• Python 3.2 70.38 sec

There’s two big shockers here.  The first is that Pypy was the fastest implementation.  That’s a pretty big shocker to me anyways.  However, the other big shocker was that Groovy with “dynamic” types was actually straight up faster than fully qualified Java-named-Groovy.  I don’t even know what to make of that so I’ll probably explore it a bit.  I currently have all the source code if anyone is actually curious and wants to try to reproduce it.

Filed under: Software Development

Drunk Liang, Best Liang

First off: let me apologize for my extended absence.  It’s not that I’m not thinking about posting, it’s just that life’s been a bit unkind.  My wife is pretty sick and the project at work is Epic Failing, so I haven’t had any time, effort, or energy to devote to forum warrioring and blogging.  I have, however, had time time to get absolutely smashed and miraculously type the password to log into Eve.

Man, there’s been so much inner-corp crap happened since last time I blogged.  Here’s a quick rundown:

• We moved out of the C2 / Low Sec + C2 wormhole.  The core problem was that the wormhole always opened up to the same set of low sec systems, and those systems were pretty bad.
• We moved briefly to Minmatar low sec while everyone regrouped out of the wormhole.
• Several people started playing League of Legends.  I think they died or something.  Haven’t seen them since.
• We moved to Syndicate and have started to slowly reform under the old No Salvation banner as Tomin took over again.

Of course, there’s a lot that could be said about each of those times, but this will have to do for now. So somewhere around the time we move to Minmatar low sec, my wife’s condition deteriorated pretty severely and my time for personal projects (including Eve) began to suffer.  Things deteriorated again recently, and lately it’s become the rule that I’m pretty lit up by the time I log into Eve (if I I log in at all).  I’m told of how I recklessly charge ahead and kill anything that’s nearby, finishing the night by chasing down and killing an X-type fit 100mn PVP Tengu for us.  I also apparently try to solo Sleipnirs in a Brutix with the rest of his gang on the way.  Got him into armor, amazingly.  Without the gang there I might have even got him into structure or even won, judging from the fraps.

I briefly mentioned the work front, but that section of the blog post grew substantially, so I’ll put it in it’s own section.

Filed under: Eve, Gaming, Drunk, Eve, PVP