It seems Google haven’t really studied the book though, as they’re not making this happen naturally or with minimum effort — virally, in modern business speak. If Google Chrome Frame installed in IE for some site as readily as flash installs, this would be a hugely significant release. Seems they’ve missed a trick here.

Some time ago, I blogged about Pluggable Django and How I hate repetiting myself. That was mostly about current but messy code I was using, which allowed me to automatically add decoupled apps to a django project without having modify the rest of my django project each time. Apps were auto-detected, and loaded, including templates etc.

Since then, I’ve been re-working this code a little. It hasn’t been high priority, since django is not a tool I’ve needed on current projects, but I did manage to get something up on github a few days back:

• Blitzen Project
• Blitzen App

So basically, these are git repositories for “django-admin startproject” and “./manage.py startapp” replacements. To start a project, just clone the Blitzen project url, and to create an app within that, clone the Blitzen app url. Note that most of the new code here is in a directory called quickening, which was a previous working title for this stuff.

So what does it do? Well, currently, not as much as my old code, in that it doesn’t really handle templates etc. just yet (the code might be there for that, but it’s untested). Things you’ll notice:

• settings.py is a lot more manageable. Most of the complex config is moved into the library code and called
• Load order of middleware is worked out automatically, by specifying dependencies. Code for this is very straightforward, in quickening/deps.py, with the dependencies currently in quickening/apps.py
• If I recall correctly, app dependencies aren’t handled yet, but the middleware dependency code was written to also support automatic dependency resolution for apps, including specifying dependencies within an app itself, rather than in the project that hosts an app. More work on this is probably required.
• there is no default SECRET_KEY any more. Instead, secret keys are auto-generated and kept in files which are ignored by git, meaning that when you checkout the code, or push the code to a webserver, each new instance gets its own key automatically.
• sqlite is configured by default

Ideas, suggestions, flames, code, etc. welcome

Apparently they tried to talk Riverbank Computing into releasing the PyQt bindings as LGPL, but Riverbank wouldn’t cooperate. Presumably Riverbank wanted Nokia to pay them a stack of money, forgetting that Nokia, owning Qt, could undercut them by just rewriting the thing themselves.

Either way… this is nothing but good news for Python+Qt fans I think. Not only do we get new, LGPL bindings, but they’re official, and will probably be better synced with official Qt releases. Who knows? They might even be documented

Oh, and it’s written in python

UmS6D0aW62+q!'%S2 (perfection:   0%) Evolving        2nd generation.
aUKahChc.5,e&8:?1 (perfection:   0%) Evolving        3rd generation.
bYJo$F?O2;aTV'q'? (perfection:   0%) Evolving        4th generation.
P]N0+dC=p-GVh<p1E (perfection:   0%) Evolving        5th generation.
P]N0+dC=p-GPQ>+6b (perfection:   0%) Evolving        6th generation.
Q?T1LHOp=LSj*VUr0 (perfection:   0%) Evolving        7th generation.
ob3<2Ih=p-CO^f#`5 (perfection:   0%) Evolving        8th generation.
dK8:SCn^omSj*VO ` (perfection:   0%) Evolving        9th generation.
X@Z'H<f.)T?f&(i6. (perfection:   6%) Evolving       10th generation.
g&H0+)DG^J%GV(\(l (perfection:   0%) Evolving       11th generation.
dK9K3Vf.)T?f&`Kfq (perfection:   6%) Evolving       12th generation.
8@Zm`,jZ-*jf38":; (perfection:  12%) Evolving       13th generation.
g&l:7O^q0jGA2r2,& (perfection:  12%) Evolving       14th generation.
j^4'N.:L0fV.9_Psi (perfection:  18%) Evolving       15th generation.
co2sL:BLffGA2((Y! (perfection:  18%) Evolving       16th generation.
MHX<oUL$EP`<o(\si (perfection:  18%) Evolving       17th generation.
g9l#bkrL$+e &>Tsr (perfection:  24%) Evolving       18th generation.
Pibho,MYilkEo(.sj (perfection:  29%) Evolving       19th generation.
cel/opLRP2aEerTs! (perfection:  35%) Evolving       20th generation.
HR(so ELrfef/\-s& (perfection:  41%) Evolving       21st generation.
ce>l9dr3iPef?r2sc (perfection:  41%) Evolving       22nd generation.
HRl#) EaibkforTs! (perfection:  47%) Evolving       23rd generation.
Ho9ho, LJ-?fY>ms! (perfection:  53%) Evolving       24th generation.
He^j`,YLrfeHFlms! (perfection:  53%) Evolving       25th generation.
HRli*/ Lrfe &rms! (perfection:  59%) Evolving       26th generation.
HelBNd Lrfe &rms! (perfection:  65%) Evolving       27th generation.
HeGlo,jLifGf&rm]! (perfection:  71%) Evolving       28th generation.
ce4lod >iWeforms! (perfection:  71%) Evolving       29th generation.
H&lho, Lif@forms! (perfection:  82%) Evolving       30th generation.
HRllo, >ifeforms! (perfection:  88%) Evolving       31st generation.
Hello,:Lif@forms! (perfection:  88%) Evolving       32nd generation.
He9lo, Lifeforms! (perfection:  94%) Evolving       33rd generation.
Hello, LifeformN! (perfection:  94%) Evolving       34th generation.
HelloV Lifeforms! (perfection:  94%) Evolving       35th generation.
Hello, LifefKrms! (perfection:  94%) Evolving       36th generation.
Evolved to 100% perfection. Concluding.
 
35,000 individuals sacrificed their lives
so that their species could eventually say:
 
        Hello, Lifeforms!

The Challenge

So… the other day, Steve drew my attention to this craigslist “to all those who think themselves a programmer” challenge. To cut a long story short, the advert included a programming challenge, and mentioned that a genetic algorithm that could say Hello World using the sacrificial efforts of billions of evolving entities would be one of the winners.

Now, it just so happens that I wrote a pretty fun Genetic Programming app as my first foray into linux C++ programming back in the mid 90’s, and had lost the code for it. So, last night, I rewrote a cut-down version of it in Python.

#!/usr/bin/env python2.6
#
# Copyright (c) 2009 Lee Braiden <lee.b@irukado.org>
# Released under the GNU General Public License, version 3.
# http://www.gnu.org/licenses/gpl.html for details.
#
 
import sys
from random import randint, sample
 
class Mirror:
	"""Stores certain details that individuals must analyse
	and evolve themselves against.  Named after the
	psychology concept of being a mirror for an individual's
	own thoughts."""
	def __init__(self, destiny):
		"""Takes a string, 'destiny', which creatures must
		evolve to say."""
		self.UPPER = max([ ord(x) for x in destiny ])
		self.LOWER = min([ ord(x) for x in destiny ])
		self.destiny = destiny
 
	def chromosome_len(self):
		"""Returns the number of chromosomes in an individual's
		genes.  In other words, this is the length of the message
		characters should evolve to say."""
		return len(self.destiny)
 
	def range(self):
		"""A quick (readability-)helper function, which allows looping
		over each gene."""
		return range(0, self.chromosome_len())
 
class Individual:
	"""Represents an individual beastie which will be created, can
	breed, can mutate, can attempt to solve the problem at hand,
	and can be tested for fitness, among other things."""
	def __init__(self, chromosome_len, mutation_rarity):
		self._genes =  " " * chromosome_len
		self.fitness = 0
		self.mutation_rarity = mutation_rarity
 
	def _gene_val(self, mirror):
		"""Create a random gene value"""
		return chr(randint(mirror.LOWER, mirror.UPPER))
 
	def _randomise_genes(self, mirror):
		"""Initialise all of the individual's genes randomly.  Used
		during creation, rather than breeding"""
		self._genes = "".join([ self._gene_val(mirror) for idx in mirror.range() ])
 
	def _choose_gene(self):
		"""Choose an individual gene to target."""
		return randint(0, len(self._genes)-1)
 
	def _freaky(self):
		"""Roll a dice, and see if this individual is (un)lucky enough
		to gain a mutation."""
		return randint(0, self.mutation_rarity) == 0
 
	@classmethod
	def conjure(cls, mirror, mutation_rarity):
		"""Create an individual from scratch."""
		i = cls(len(mirror.destiny), mutation_rarity)
		i._randomise_genes(mirror)
		return i
 
	@classmethod
	def breed(cls, mirror, mom, dad):
		"""Breed an individual from two parents."""
		mutation_rarity = float(mom.mutation_rarity + dad.mutation_rarity) / 2.0
		kid = cls(len(mirror.destiny), mutation_rarity)
		x = kid._choose_gene()
		kid._genes = "".join(mom._genes[:x]) + "".join(dad._genes[x:])
		if kid._freaky():
			kid._mutate(mirror)
		return kid
 
	def _mutate(self, mirror):
		"""Mutate a random gene"""
		orig_genes = self._genes
		idx = self._choose_gene()
		els = [ x for x in self._genes ]
		els[idx] = self._gene_val(mirror)
		self._genes = "".join(els)
 
	def self_evaluate(self, mirror):
		"""Evaluate 'fitness', or the ability to solve the given
		problem.  In other words, measure how close the individual
		is to the correct message text, and assign a score
		accordingly."""
		fitness = max_fitness = float(len(self._genes))
 
		for idx in range(0, len(self._genes)):
			if self._genes[idx] == mirror.destiny[idx]:
				continue
			else:
				fitness -= 1
 
		self.fitness = 100.0 * (fitness / max_fitness)
 
	def __cmp__(self, competitor):
		"""Comparison function, used for sorting populations to find
		the fittest."""
		if self.fitness > competitor.fitness:
			return 1
		elif self.fitness == competitor.fitness:
			return 0
		else:
			return -1
 
class World:
	"""Represents a world populated by Individuals, which breed
	together, subject to natural selection, to reach an evolutionary
	goal."""
	def __init__(self, mirror, population_size=1000, mutation_rarity=1000, fitness_required=100.0):
		"""Initialise a population of population_size members, mutating
		one in every mutation_rarity breeds.  Evolution will stop when
		fitness reaches fitness_required percent."""
		self._mirror = mirror
		self._population = [ Individual.conjure(mirror, mutation_rarity) for i in range(0, population_size) ]
		self.sacrifice_count = 0
		self._fitness_required = 100.0
		self._mutation_rarity = mutation_rarity
 
	def _natural_select(self, exclusion_list=[]):
		"""Select two individuals from a population, choosing the most
		'fit' for breeding."""
		a,b = sample(self._population, 2)
		if (a > b):
			return a
		else:
			return b
 
	def _breeding_pairs(self):
		"""Select enough breeding pairs from a population to create a
		new population of equal size, assuming one child per couple."""
		bp = []
		pop_size = len(self._population)
 
		for i in range(0, pop_size):
			mom = self._natural_select()
			dad = self._natural_select([mom])
			bp.append((mom,dad))
 
		return bp
 
	def _breed_new_generation(self, mirror):
		"""Create a new generation, breeding it from the older
		generation using natural selection."""
		new_gen = []
		bp = self._breeding_pairs()
		for mom,dad in bp:
			kid = Individual.breed(mirror, mom,dad)
			new_gen.append(kid)
 
		self.sacrifice_count += len(self._population)
		self._population = new_gen
 
	def _analyse_population(self):
		"""Evaluate the genetic fitness of the entire population."""
		for i in self._population:
			i.self_evaluate(self._mirror)
 
		self._population.sort()
		most_civilised = self._population[0]
 
		return most_civilised
 
	def evolve_civilisation(self):
		"""Evolve this civilisation until the required fitness_level
		is reached."""
		generation_count = 1
		last_str_len = 0
		while(generation_count):
			most_civilised = self._analyse_population()
			gen_ord = ordinal(generation_count + 1)
 
			if most_civilised.fitness >= self._fitness_required:
				print "Evolved to %3.0f%% perfection. Concluding." % most_civilised.fitness
				return most_civilised
			else:
				print "%s (perfection: %3.0f%%) Evolving % 10s generation." % (most_civilised._genes, most_civilised.fitness, gen_ord)
				self._breed_new_generation(self._mirror)
 
			generation_count += 1
 
# a couple of helper functions #############
 
def ordinal(n):
	"""borrowed from John Machin's python-list post.  Appends an
	ordinal suffix to a number.  For example, 1 becomes 1st,
	2 becomes 2nd, etc."""
	if 10 <= n % 100 < 20:
		return str(n) + 'th'
	else:
		return  str(n) + {1 : 'st', 2 : 'nd', 3 : 'rd'}.get(n % 10, "th")
 
 
def PrintLargeNumber(n,width=2,delim=',',decimal='.'):
	"""Converts a float to a string with appropriately placed commas.
 
	Floats will be shown with 'width' digits right of the decimal.
	'delim' specifies the thousands delimiter.
	'decimal' specifies the decimal character.
 
	Copyright 2007 Regents of the University of California
	Written by David Isaacson at the University of California,
	Davis BSD License"""
	if width >= 0: s = "%.*f" %(width,n)
	else: s = str(n)
	dec = s.find(decimal)
	if dec == -1: dec = len(s)
	threes = int((dec-1)/3) # we don't need a comma at the start
	for i in xrange(threes):
		loc = dec-3*(i+1)
		s = s[:loc] + delim + s[loc:]
	return s
 
############################################
 
def evolve_from_nothingness(msg):
	"""Evolve an individual capable of saying the given msg."""
	world = World(Mirror(msg))
	greeter = world.evolve_civilisation()
 
	large_num_str = PrintLargeNumber(world.sacrifice_count, width=0)
 
	print "\n%s individuals sacrificed their lives\nso that their species could eventually say:\n\n\t%s\n\n" % (large_num_str, greeter._genes)
 
 
if __name__ == "__main__":
	evolve_from_nothingness("Hello, Lifeforms!")
 
	sys.stdout.write("Press return: ")
	sys.stdout.flush()
	sys.stdin.readline()

All in all, it’s pretty sweet. It evolves fairly constantly, straight to the answer, in less than 40 generations. Completes in a few seconds as well.

I’ve no doubt the SF Bay guys would find problems with this. They’re into pointlessly obfuscated code, FP, and lambdas, for instance. I’m into pointedly unobfuscated code, and using FP only when it makes things much clearer. And optimisation is for compilers long after your algorithms and portability have done their thing. That said, most of this IS off the top of my head, and I’m sure there are better ways to do it, so let me know if there are obvious (or not so obvious) improvements that can be made.

Anyway… for me, this is what programming’s all about. In what other fields can you create worlds, create lifeforms, prove that evolution works, test yourself, frustrate yourself, and enjoy seeing your project finally work, all in the space of a few hours?

I should probably thank the python guys for a lot of that rapid development; the C++ version took much longer. Then again, it had a virtual CPU and datatyped I/O etc. I think it was threaded, too, if I remember correctly. It also took hours to work out that the way to get 4 out of two 2s was to add them. I might try that again someday, with a tweaked CPU/instruction set/program model.

However, the real gems are hidden away towards the end of the tour: blender’s UI options are now implemented in pure Python, and you can code, press a refresh key, and have new options appear in the UI straight away. This is the feature I’ve been hoping for in blender for ages now. 2.4’s roadmap included an updated UI, and I proposed something like this, so I was pretty disappointed to see that nothing much happened on the UI front. For a while there, it looked like 2.5 would be equally intransigent.

That has NOT been the case though. Now, it’s possible to write python plugins for blender, and have them be fully integrated, as if they were part of the core code. They’ve even gone a step further, and made it very nice and standardised to use; you don’t need to specify buttons for the UI, so much as specify variables and their types. The rest is done for you, via Blender’s RNA type system. Seems they’ve setup fairly rich datatypes/widgets, too.

The upshot of all this? The whole thing seems nice enough now that I’m a lot more tempted to write blender plugins. It’s occured to me now and then that blender would be much cooler with 3D audio objects — speakers, dampeners, echoers/reflectors, and microphones in the scene used to produce animated positional audio, just like it currently has lights, materials, reflectors, and cameras to produce animated video.

I expect too, that, since plugins are much more integrated now, there’ll be an exponential increase in their use and development by others.

Congrats to everyone who’s worked on 2.5. It’s been a while coming now, but 2.5 looks amazing.

I’ve been holding off on playing with TG2 too much, since it wasn’t final, but now I’m gonna have a good play. It’ll be interesting to compare this with django, cherrypy 3, etc.

The original bug report, by Matt Lee, founder of libre.fm, reads:

With the release of “Ubuntu One” and the news that Launchpad will not be released as free software, Canonical’s message: “Canonical is committed to the development, distribution and promotion of open source software products, and to providing tools and support to the open source community.” is no longer true, and its continued association with Ubuntu is damaging to free software.

Canonical should decide if it wants to be committed to the development of free software or not.

Canonical employees should decide if they want to be seen to work for a proprietary software developer, whilst talking about free software.

Canonical should either release publically, all the source code for Launchpad and Ubunet, or it should update its mission statement to state their commitment to the development of proprietary software.

The Ubuntu community should decide if they want to be associated, governed and ruled by a proprietary software company, and should appoint non-Canonical people to all the key positions.

Mark Shuttleworth (founder of Canonical), has responded to it with:

Ubuntu was founded together with Canonical, they have always been (and I hope they always will be) intertwined and interdependent. There are thousands of projects and hundreds of distributions, which have various degrees of involvement between themselves and companies. Contributors already align themselves with the projects that reflect the things they are most interested in.

Personally, I think the company/project interface and interaction makes the landscape interesting. We’re all trying to figure out the future of software, and perhaps the future of the software business at the same time.

I understand the passion behind this bug report, but I don’t think it can be addressed. The people who make up the Ubuntu community are entirely free to devote their energy to whatever path they think will serve their interests best – and that has always been the case. I suspect most people in this community are drawn here precisely because of the interdependency between project and company. And those who don’t may well be drawn to something which flows as a direct consequence of that.

There are several distributions which make a point of having no corporate backer. The people who want that, specifically, are probably already there, happily doing good work. People who want something else are wherever they think they can find that, happily doing good work. Some people may change their mind and move in either direction. But Ubuntu and Canonical were born together, with a shared mission. If that’s interesting to you, then participate in Ubuntu. If it’s not, then don’t.

Personally I think the bug report is entirely correct. Ubuntu was always a commercial venture to me; it’s always been clear that shuttleworth intended to make Ubuntu big, then profit from it. But the way he’s doing it — by going against free software while claiming to be a spokeperson in favor of it — is not only incoherent, but damaging to the community. It affects people involved in Ubuntu even more so, since (as the bug report suggests) they’re now involved with a company of questionable ethics, beliefs and practices which may not align with their own.

The most worrying parts for me were Shuttleworth’s comment that “[he] understand[s] the passion behind this bug report, but [doesn't] think it can be addressed”, his change of the bug status to “won’t fix”, and the comment that “The people who make up the Ubuntu community are entirely free to devote their energy to whatever path they think will serve their interests best – and that has always been the case”. This last is patently false, since Ubunteros have to commit to an ethical policy. I haven’t re-read it in light of this development, but I’d be surprised if that ethical policy for Ubuntu contributors allows the kind of commercial actions that Shuttleworth himself is attempting. What I think Mark means is that he owns the company, so everyone else can either like it, or get stuffed. Hell, that’s pretty much his exact wording. Which is precisely the OPPOSITE of the ideal spirit of FOSS community participation.

I really don’t get why he’s doing it this way. It seems pretty clear that if Ubuntu creates a proprietary product good enough that Linux users want it, then FOSS developers will simply bypass his underhanded attempts at control by creating a free clone. Surely selling high-end tech support, on-site/remote admin, printed documentation, etc. would be a much more natural model for them? Then again… you can’t get quite so rich selling physical services, as you can selling automated, virtual ones, and Shuttleworth’s previous success was built on that virtual model.

Anyway… I for one am glad to say that I’ve gone back to Debian before this came out, simply because I find Debian better, for many reasons. Basically, it’s the original and best, which Ubuntu adds very little on top of, and when it does, Debian soon adds those features back. If you’re still with Ubuntu, and value free software, or don’t want to be associated with this sort of anti-community behavior, you might want to consider a switch. Certainly, I think it’s time to stop recommending Ubuntu when other distros provide equally viable but more principled alternatives.

Update:

It seems there’s also a related bug about Ubuntu One violating Ubuntu’s trademark usage guidelines:

The usage of the word Ubuntu in the context of “Ubuntu One” is inconsistent with the Trademark Policy outlined at http://www.ubuntu.com/aboutus/trademarkpolicy

Specifically of note are the following:

The objective of the Ubuntu trademark policy is to encourage widespread use of the Ubuntu trademarks by the Ubuntu community while controlling that use in order to avoid confusion on the part of Ubuntu users and the general public, to maintain the value of the image and reputation of the trademarks and to protect them from inappropriate or unauthorised use.

The danger of confusion among users and the general public about whether this new service is part of or associated with Ubuntu is extremely high.

there is no commercial intent behind the use

The service has clear and stated commercial intent.

what you are referring to is in fact Ubuntu. If someone is confused into thinking that what isn’t Ubuntu is in fact Ubuntu, you are probably doing something wrong

The service is not Ubuntu and has no association with Ubuntu as a product or community. It merely runs on and works with Ubuntu, on equal footing with other applications like Apache, Firefox, or an Ubuntu user’s blog.

there is no suggestion (through words or appearance) that your project is approved, sponsored, or affiliated with Ubuntu or its related projects unless it actually has been approved by and is accountable to the Ubuntu Community Council

I am not aware of any such approval or even discussion by the Community Council at this time.

If you are producing new software which is intended for use with or on Ubuntu, you may use the Trademark in a way which indicates the intent of your product. For example, if you are developing a system management tool for Ubuntu, acceptable project titles would be “System Management for Ubuntu” or “Ubuntu Based Systems Management”. We would strongly discourage, and likely would consider to be problematic, a name such as UbuntuMan, Ubuntu Management, ManBuntu, etc. Furthermore, you may not use the Trademarks in a way which implies an endorsement where that doesn’t exist, or which attempts to unfairly or confusingly capitalise on the goodwill or brand of the project.

The service clearly falls under the latter list of examples similar to UbuntuMan, and as such is named unacceptably. Furthermore it appears to be attempting to capitalize on the brand, which is similarly explicitly prohibited.

Proposed fix
Rename the service to not include the words “UBUNTU, KUBUNTU, EDUBUNTU, and XUBUNTU” nor “any mark ending with the letters UBUNTU or BUNTU”, or in an acceptably non-ambiguous manner such as “Cloud Storage Solution for Ubuntu”.

This all seems like a clear case of Canonical violating the core principles of Ubuntu for commercial gain, which saddens me.

What they seem to mean, sadly, is “how to make citizens comply with the illegitimate mess that is modern Copyright law”. I have a few thoughts on this, which I wanted to “get down on paper”.

Questions

The questions which the IPO is asking are as follows:

1. How to educate and change consumer behavior towards copyright material
2. How to support industry efforts in developing new and attractive legal ways for consumers to access content
3. How to support legislation to address consumer activity that breaches civil copyright law and how to tackle persistent infringement
4. How to enable technical copyright-support solutions that work for both consumers and content creators
5. Whether or not the Agency should be an independent industry body with back-up legal powers held by Ofcom
6. How such an agency can be funded

One respresentative, namely Steven Carter (Minister for Technology, Communications and Broadcasting), also stated that:

“In the new digital age, copyright infringement has become easier and more socially acceptable, so it’s clear we need some form of legislative backstop for the protection of rights as well as new and innovative ways to access legal content. Today we have published proposals in the form of a Straw Man on digital rights. That Straw Man could be torched, tolerated or a touchstone for the start point of constructive debate and design.

Interesting that they admit the use of a Straw Man (a fallacy) as their starting point, yet do not shrink from moving forward on enforcement and “educating” the public with such fallacies.

Education of consumers and modification of their behavior is a false (and dangerously presumptive) premise, and not at all the issue. The issue is that organisations generally known as “big media” have, over the course of many years, perverted the Copyright system to their own ends. It is the corporations, and the government that have allowed this perversion and enforced it, which need to be re-educated.

The Fundamental premise of Copyright

Copyright was created, (ostensibly, that is) as a way to encourage creative contributions to society. The idea was that, by preventing others from copying an idea for a short time, those who spent the time to come up with the initial idea would be rewarded. The fear (ostensibly), was that without rewards, people would not create. That fundamental premise alone, I would very much contest, given that people have created since the dawn of time. I believe it is in peoples’ nature to create, and that true creation is done for the love of the idea inspiring it. Whenever I’ve been possessed of a creative idea, it was just that — a possession by the idea, to the point where I could not wait to bring it to life, to enjoy its realisation, to share the benefits with others, and to enjoying seeing their joy in return. I also tend to take time to thank those that inspired me, thereby completing a cycle. Likewise, people have thanked me for my work and built on it in their own ways, adding just a little more joy to my creations. In fact, I’ve met many more artists (including painters, musicians, writers, etc.) working for the love of their art than for monetary rewards.

Holding back society

Today, it is more and more the case that big media is holding back society by controlling the creativity and communication between citizens due to ever extended copyright terms (in fact, copyright terms should be shrinking, due to faster distribution methods), DRM, the application of copyright law to private use (rather than commercial ventures), etc.

Creativity, and creative works, are a fundamental form of expression and communication between human beings. Invariably, this creativity is nothing more than each person standing on the shoulders of those who came before, and invariably, no creator is unique, when other potential creators also have access to the same pre-existing works. For instance, Albert Einstein, one of the greatest, most innovative minds of our era, was certainly not alone, with at least two others working on very similar ideas at the same time in history. His creative genius was but a small leap, based on the leaps made before**. Likewise, musicians have often acknowledged their influences as hugely affecting their work, and often directly take (sample) and remix the works of others, creating interesting new works with only the most minor modifications to pre-existing work. As each idea builds on the one before, each and every access to existing knowledge, art, music, film, or other media is more important than any individual right to control such access.

The obvious conclusion then, is that all individual creativity is minor, but that, where possible, ensuring all individuals (ANY and ALL of whom may go on to create even greater works) receive unfettered access to creative works is of utmost importance. This clearly shifts the natural bias towards individual’s rights to access content online, regardless of

The current system of copyright is so perversely biased towards commercial interests, despite its original intent, that it no longer represents natural rights of citizens, and no longer reflects the modern realities of distribution ease. As a result, citizens, en masse, intuitively recognise its failure to match reality in any way, and consequently reject it as invalid.

How to support industry efforts in developing new and attractive legal ways for consumers to access content

Again, the premise — that industry is making efforts, and that these efforts must be supported despite citizens wishes — is false. It is the consumers’ natural rights which are being abused, and must be reinforced, and it is citizens who must be assisted to take back those rights from the results of many years of overzealous corporate lobbying, if not downright corruption. The burden of achieving legality lies with those who have abused the legal system for years, to the point where the majority of citizens, from to the youngest child without legal knowledge to the most eminent copyright lawyers, intuitively know that the current system is broken, and therefore ignore it.

Consumers can easily access content by simply downloading a file, with by far the vast majority of costs being bandwidth costs which ARE already, entirely validly, shouldered by those same consumers. Yes — these costs, the true costs, they pay for, often at high rates, happily and legitimately. What consumers are failing to pay for is false costs and false scarcity, which they see for what it is, namely a perverse attempt to hold back society’s technological, social, and cultural progress. They reject such things accordingly, and I believe no one should expect a more fitting response to such perverse, cynical attempts.

3. How to enable technical copyright-support solutions that work for both consumers and content creators;

First of all, honesty is required on the part of government, copyright holders, and artists. The fact is that the market is flooded with musicians and media makers, and media like music is simply not scarce enough (nor such a skill these days, given software assistance) to command high prices. More importantly, creativity is not the domain the elite, but the domain of every human being with access to appropriate tools which allow them to express their creativity. Those tools are available more widely every day in the digital world, and so the day is coming when “artists” will simply be “people”. Creativity is becoming commoditised by this process, and the fact is that distribution of media is now effortless, and “big media” is simply obsolete.

IF and WHEN that realisation has been made and fully accepted by both “big media” and artists, then fair prices will be set according to supply and demand. Consumers will happily pay. But make no mistake: this will absolutely NOT resemble the mass transit of money from many poor, equally creative citizens to a few wealthy, controlling corporations controlling access to a few “successful” creatives. That situation has plagued society and copyright for the last few centuries (and ONLY the last few centuries, during which corporations have been assisted by government to abuse their power). To attempt to enforce this unfair and illegitimate status quo will serve only to create a consumer backlash which will ultimately be the undoing of the current system, rather than its savior.

4. Whether or not the Agency should be an independent industry body with back-up legal powers held by Ofcom

Absolutely not. The world is changing too quickly for law makers to keep up with. Until the situation has settled down, until the vast majority of citizens understand this brave new world fully, and are largely in agreement about the way forward, neither government nor corporations have a mandate to enforce anything. Laws represent the will of the people, not vice versa. If the law does NOT reflect the will of the people, then it cannot truly be considered valid law.

5. How such an agency can be funded

Until the current, very fundamental misunderstandings of corporations and government have been resolved, no such agency should exist, as it cannot hope to spend money on a valid goal, therefore it should not be funded. Of course, studies seeking true understanding and resolution should not be funded by any such biased organisations either.

** “Einstein did not achieve this revolution by means of a single stroke of genius—rather, he stood on the shoulders of dwarves and giants” — Science Daily, http://www.sciencedaily.com/releases/2006/07/060731113951.htm

–
Lee

Working through this in python is a very useful exercise; it’s teaching me lots about the most efficient ways of doing things in that language, and with the standard library tools, some of which I rarely find use for otherwise.

Anyway, together with some other things mentioned in the preface, Derivations seems like a very promising book. Except for one thing:

One particular respect in which the book departs requires some defense here, I think: the book employs hexadecimal numerals.

So it’s going to explain complex math, but it’s going to do it… in hexadecimal.

Not sure whether to laugh or cry. But I’ll see how it goes. I don’t entirely disagree with the idea that, “If one wishes to reach hexadecimal ground, one must leap.” It’s just that I don’t really see the point of becoming THAT fluent in hex, when understanding the basic concept of bases, and knowing how to convert from dec<>hex<>oct<>bin, that 2⁵ is 32, and that 2³² is roughly ~4 billion is almost certainly enough. Is this book really suggesting I learn to do all my math in hex? And if so, is there any real benefit? It does seem to suggest that math is more beautiful in hex, but I’ve never heard of anything special about base-16, in relation to laws of physics, for instance.

Well, find out next time, same bat-time, same bat-channel, I guess