I don’t know why they don’t use a continuous curve. Something simple like y = (log(x^4) + 10)/5 has roughly the right shape so it only has to be scaled appropriately. It would get rid of all those discontinuities, and when they go so will the income peaks at $35k and $80k.

http://betweenthebalancesheets.wordpress.com/2011/10/05/the-lessons-of-the-baby-sitting-co-op-reconsidered/

I had a number of people tell me they weren’t going to submit to the call for papers because of posts discouraging them from doing so…

*shrug*

Also – “I don’t use linux”

Dunno how we change the script in people’s heads – perhaps talking about it, and blogging about it, and perhaps getting next year’s call for papers to explicitly reach out to different groups… perhaps going back to old model and inviting speakers from under represented open source projects like Java, like BSD… rather than expecting them to submit to our rigorous CFP?

Btw pity we only saw you at a meeting once – you have excellent insights, it’d be great to have you there!

It seems fairly clear to me that the lack of JVM talks at LCA is due to a lack of submissions, but we’re doing work to make sure that talks for developers from all open source ecosystems (including OpenJVM) are welcomed there. We just need more submissions!

regards,

hothead

Perhaps the tests would be better factored as first checking on generation of the sieve, and then that the sieve is used correctly. (Or perhaps that is just arguing the example.)

for test, res, exc in run_tests(prime_test):
    if exc is None:
        if not res: print "FAIL: %s : wrong result" % (test)
    else:
        print "FAIL: %s : exception %s" % (test, exc)

Code under test is a primality test that (optionally) also does the Sieve of Eratosthenes thing to speed things up.

def euler_sieve(n):
    if n > 1000:
        raise Exception("cannot do a sieve with %d elements" % n)
    # from wikipedia
    candidates = range(n+1)
    fin = int(n**0.5)
    for i in xrange(2, fin+1):
        if not candidates[i]:
            continue
        candidates[2*i::i] = [None] * (n//i - 1)
    return [i for i in candidates[2:] if i]

def is_prime(n, sieve = None, sieve_max = None):
    if sieve is None:
        i = 2
    else:
        if n < = sieve_max:
            return n in sieve
        else:
            for i in sieve:
                if n % i == 0:
                    return False
            i = sieve_max
    while i*i <= n:
        if n % i == 0: return False
        i += 1
    return True

Test code that deals with a bunch of different cases (are we using a pregenerated sieve, does the sieve actually generate, is the number prime, a unit, negative) might be:

def prime_test(branch):
    have_sieve = branch(True, False)
    if have_sieve:
        sieve_size = branch(-1, 0, 1, 2, 10, 100, 500, 1000)
        sieve = euler_sieve(sieve_size)
    else:
        sieve_size = 0
        sieve = None
    actual_prime = branch(True, False)
    if actual_prime:
        n = branch(2, 3, 5, 7, 30133, 1231231)
    else:
        n = branch(-1, 0, 1, 4, 6, 8, 100, 1000000)
    return is_prime(n, sieve, sieve_size) == actual_prime

Failures are:

FAIL: [True, -1] : exception negative number cannot be raised to a fractional power
FAIL: [True, 0, True, 2] : exception integer division or modulo by zero
FAIL: [True, 0, True, 3] : exception integer division or modulo by zero
FAIL: [True, 0, True, 5] : exception integer division or modulo by zero
FAIL: [True, 0, True, 7] : exception integer division or modulo by zero
FAIL: [True, 0, True, 30133] : exception integer division or modulo by zero
FAIL: [True, 0, True, 1231231] : exception integer division or modulo by zero
FAIL: [True, 0, False, 1] : exception integer division or modulo by zero
FAIL: [True, 0, False, 4] : exception integer division or modulo by zero
FAIL: [True, 0, False, 6] : exception integer division or modulo by zero
FAIL: [True, 0, False, 8] : exception integer division or modulo by zero
FAIL: [True, 0, False, 100] : exception integer division or modulo by zero
FAIL: [True, 0, False, 1000000] : exception integer division or modulo by zero
FAIL: [True, 1, True, 2] : wrong result
FAIL: [True, 1, True, 3] : wrong result
FAIL: [True, 1, True, 5] : wrong result
FAIL: [True, 1, True, 7] : wrong result
FAIL: [True, 1, True, 30133] : wrong result
FAIL: [True, 1, True, 1231231] : wrong result
FAIL: [True, 2000] : exception cannot do a sieve with 2000 elements
FAIL: [False, False, -1] : wrong result
FAIL: [False, False, 0] : wrong result
FAIL: [False, False, 1] : wrong result

So you only get one message when your sieve creation fails (creating a sieve of the first -1 numbers [True, -1] fails when sqrt(-1) gets invoked, and for the first 2000 numbers fails because it's deliberately disabled), but when sieve creation (apparently) succeeds you get results for each of the following-on branches you've setup.

The situation he describes could be described as an application of the Chained Tests pattern, and it has mixed benefits. One of the benefits is that you may need less explicit setup code; one drawback is it’s hard to implement correctly and hard to maintain in non-pure languages and in particular it is hard to have branching.

The kind of case you’re describing is something a lot like what testscenarios handles:

class TestPrimality(TestCase):
scenarios = [(str(a), {'number': a, 'prime': b)
for a, b in
[(1, True), (2, True), (3, True), (4, False), (6, False)]]

def test_is_prime(self):
self.assertEquals(self.prime, is_prime(self.number))

class Brancher:
    def __iter__(self):
        return self

    def next(self):
        if not hasattr(self, "idx"):
            self.idx = []
        elif self.nxt is not None:
            self.idx[self.nxt] += 1
            self.idx[self.nxt+1:] = []
        else:
            raise StopIteration()
        self.vals = []
        self.cnt, self.nxt = 0, None
        return self

    def __call__(self, *options):
        if len(self.idx) == self.cnt:
            self.idx.append(0)
        n = self.idx[self.cnt]
        if n+1 < len(options):
            self.nxt = self.cnt
        r = options[n]
        self.vals.append(r)
        self.cnt += 1
        return r

Then you can do something like:

for branch in Brancher():
    n = branch(*range(2,10))
    m = branch(*range(2,10))
    if is_prime(n*m):
        print "FAIL: is_prime(%d*%d) = TRUE" % (n, m)

and have the loop cover all combinations of the branches. The run_tests function then becomes:

def run_tests(test_fn):
    for branch in Brancher():
        try:
            res = test_fn(branch)
        except Exception as e:
            yield (branch.vals, None, e)
        else:
            yield (branch.vals, res, None)

(at least, it does when you add in support for exception handling).

import guif, wx
frame = guif.dispguif("Enter some text: %(edit)250t \n %(button)b",
                      "", "Press me!",
                      ExitOn = ("button", wx.EVT_BUTTON))
guif.dispguif("You typed: %l", frame.edit.GetValue())

That sort of setup can certainly increase demand for connection speed — but demand for connection speed is the thing they’re assuming won’t grow as fast as it historically has in their profit projections. I haven’t double checked the numbers, but I’m pretty sure that the historical growth figures were for pretty much a constant price point too.

It is entirely possible the price for bandwidth with go up with inflation while the costs per byte delivered go down. Thus is it not necessary for them to quote “inflate the cost per GB”. Besides, I suspect something close to what they are planning has been happening for a while now. The raw cost of a telephone line rental hasn’t changed much over the years. In fact I vaguely recall it going up. Yet the total price charged per byte on my internet connection has gone down. I guess that must be probably because the ISP’s are now paying less for overseas bytes.

I think the most interesting thing about this is how you will be sold bytes, and who will be selling them to you. I can’t see how the current cable network will be sustainable. Assuming you write off the capital costs of building it, there is still the ongoing maintenance cost, and surely the NBN will be able to provide the same service cheaper because they can split the maintenance cost over several uses (voice, TV, Internet).

I can’t see your local ISP being too keen on the idea of charging you the same rate for each of those bytes. An internet byte may come from overseas, and so costs them a lot more than a TV byte coming from some local server. Australian ISP’s already charge cheaper rates for some bytes now of course, as they have free zones. Maybe in future in addition to free zones we will have real time tv zones, voice zones, background download tv zones, global internet zone. It take is how it pans out, I suspect that like ISP’s VOIP services do now, these zones will come different QOS guarantees. How that will fit in with the “Net Neutrality” sacred cow is a bit if a mystery.

But then again, the NBN can save the cow by deciding it is easier to do the multiplexing themselves. In that case they will slice and dice the bytes so your ISP gets some fixed chunk of bandwidth, Foxtel some other fixed chunk, your voice provider such as Optus/Telstra another and so on. The cable is just carrying etherne frames after all, and ethernet supports VLAN’s.

This is all wild speculation of course, and I’d be surprised if anybody has a clue where this is going to end up. The current ISP’s, telco’s, pay tv, video stores, indeed anybody who makes their living from transporting bytes (its interesting to think of video stores in that way) are probably all looking on very nervously. The shit is approaching the fan. Timing when to duck is everything.