I want to be jolted from sleep at 8:00AM every day except Saturdays and Sundays. Good old fashioned Unix cron is a perfect fit for this requirement. You can edit your crontab quite easily by running:

env VISUAL=gedit crontab -e

Add the following lines to make cron run the program ~/bin/wakeup every weekday at 8:00AM:

# minute hour day month dayofweek    command
  0      8    *   *     mon-fri      /bin/sh ~/bin/wakeup

Cron isn’t always enabled by default in some distributions. See your distribution’s documentation for how to turn cron on. For Ubuntu users, see Ubuntu’s Cron Howto.

You can test that cron works by adding

 * * * * * mkdir -p ~/crontest

to your crontab, then waiting for sixty seconds and checking that a directory called ~/crontest has been created. If it has, then remove the test line from your crontab and rejoice that cron works.

I put my wakeup script in ~/bin. You can create the file using the commands:

mkdir -p ~/bin      # make sure the directory ~/bin exists
gedit ~/bin/wakeup  # edit the wakeup script

The contents of my wakeup script are pretty simple. The first thing I do is turn my speakers on at full blast using ALSA’s non-interactive mixer client. (In case you’re wondering, there is a friendlier way to set ALSA’s volume from a terminal – just use alsamixer.)

Change the values from 100 to something more reasonable if this is too loud.

# Note that "Speaker" might be called "Front" instead on some machines.
# If you get the error "amixer: Unable to find simple control 'Speaker',0",
# then try using the other name.
amixer sset Speaker 100 unmute
amixer sset Master 100 unmute

Next, I use mpd to start blasting music. I find mpd exceedingly handy because it runs unobtrusively in the background, and has a variety of frontends – there are about eight graphical clients for mpd at my last count, one that runs nicely in Terminal using ncurses, and one plain, boring, easily-scriptable command-line client called “mpc”.

Setting up mpd and showing it where your music is and everything is a little more involved than I actually want to go into here right now. Fortunately, there is a good guide to setting up mpd in Ubuntu in Ubuntu’s community documentation.

Having mpc throw away the current playlist and replace it with a new one is quite easy.

mpc clear
mpc load awaken
mpc random on
mpc repeat on
mpc play

This loads and starts the playlist called “awaken” – which on my machine I’ve filled (in advance) with nice, loud rock music, the odd bit of metal, and at least one song by Aqua.

I’ve deliberately left shutting it up afterwards out of my wake-up script; I’m much more likely to make it out of bed if I need to actually walk across the room, manually fire up Terminal, and type

mpc stop

in order to kill the Aqua.

If you do really want to make the wake-up script shut up after ten minutes, then add to the bottom of the wakeup script:

sleep 600  # leave mpd playing for ten minutes
mpc stop   # and then go quiet

Before you kick off your shoes and hit the hay, it’d be a wise idea to make sure that the wakeup script will actually work when cron tries to run it. You can run it manually with the command:

/bin/sh ~/bin/wakeup

If that works then you’re done. Sweet dreams!

This is a very interesting topic to me. With my leniency towards very specific definitions, I’m going to start right from the start, and explain that I’m certainly not a believer in Wittgenstein’s views on natural language.

To me, it’s not unreasonable to define a strict subset of natural language with a single, well defined, 1-1 semantic value function for discussing technical matters (and I believe the definition of “viral” should fit into such a subset), in the same way that we define mathematical terms in first order logic (I’m not going to get into provability here).

i.e. I think that it’s possible, and reasonable, to define the meaning of individual words which are indisputable and fixed when talking in technical language.

For this reason, it really drives me up the wall when two people talk about something, use the same word, but are actually discussing different things.

An example is how we have recently changed the naming for our “Syndicated Ad Units” (Previously “Content Units”).

When we define terms for such a large system, we are effectively defining our own language (or at least the non-common alphabet – technically the set from which words are taken rather than set from which letters are taken). By changing the naming for the system, we have effectively created a second language.

These languages are technically as distinguishable as programming languages are – and switching between requires the same work as switching between programming languages.

Obviously we don’t want too much redundancy in our alphabet, or we end up

• Having to remember a much larger set of nouns
• diverging strongly from a 1-1 semantic value function, which is indistinguishable from the effect of losing orthogonality of the semantic values of individual nouns

To explain the second point, if we mark the semantic value function of a language “I” (for “interpretation”), and we have an alphabet that consists only of the words “abc”, “def” and “ghi”, then if we have orthogonality in semantic values of the nouns, we would have that changing the meaning of “abc” – marked I(“abc”) (though adding functionality to the thing we call “abc”) changes I(“abc def”) in the same way as I(“abc ghi”) changes. It also implies that I(“zyx…wv”) does not change  unless “abc” is part of “zyx…wv”.

We did a very interesting thing while we changed the language used for syndication – we changed which objects have their own names. This changes the set of concepts that can be described with a single word – {I(a) for a in the alphabet}, rather than simply changing the strings used for the objects in the alphabet.

This fundamentally changes the language, and changes the effort required when semantic value functions change (as they always will on a long term software project).

For example, let’s take some of the objects that have changed names (you can see what the semantic values of these names are here):

* “(gadget)” is added internally for this type of Fun Unit.

By enforcing these changes, several changes to the alphabet are implied – firstly the fact that we do not use “gadget” externally creates two alphabets, and hence two new languages – but the aim is to keep one language a subset of the other one.

Previous alphabet:

“Med. Rect.”, “Gadget”, “Content Unit”, “Text Link”, “Text/Image Link”, “Fun Link of the Day”

New alphabet (internal):

“Med. Rect.”, “Fun unit”, “Gadget”, “Text Link”, “Fun Links”, “Text and Image Link”, “Fun Link of the Day”

New alphabet (external):

“Med. Rect.”, “Fun unit”, “Text Link”, “Fun Links”, “Text and Image Link”, “Fun Link of the Day”

Now let’s look at how orthogonal the meanings of these are…

if we suddenly decided to break years of internet tradition and say that a “Med. Rect”  was actually 1024 pixels wide and one pixel high – that would effect all names with “med. rect.” in them equally. In fact, the meaning has not changed at all between the two languages – it defines the size that the syndicated placement will take up on your website.

similarly, the meaning of “Text Link” has not changed (and although we changed the string “Text/Image Link to “Text and Image Link”, the actual interpretation of these strings has not changed).

If you are looking closely though, you will have noticed that “Fun Link of the day Text Link Content Unit” has changed to “Fun Link of the day Fun Links” – this is an important change, since they have the same interpretation, the meaning of “Text Link” has not changed, and yet “Text Link” is not in the new name. This means that this semantic value must be associated with the phrase “Fun Link of the Day” – and so it is. But “Fun Link of the day” is also associated with a size (this is more obvious in the origional naming conventions) This is a many-1 mapping between the old language and the new one, and as such it changes the implied syntax quite dramatically.

Now for the most interesting strings – “Content Unit” has been changed to either “Fun Unit”, or “Fun Links”. This is very clearly a 1-many mapping during the changeover, which again changes the syntax of the language dramatically.

For example, let’s imagine (and this is purely imaginary), we decided to add a feature that (describing the semantic change in the old language) allowed you to “place your content unit in an RSS feed”.

In the old language, we have just updated the semantic value of “content unit”, however in the new language we have updated the semantic value of “Fun Unit” and “Fun Links”. Thus they are non-orthogonal (in fact, in terms of this change they would be parallel!).

For a user (of the language) who understands the new semantic value of “Fun Unit”, they cannot know that the semantic value of “Fun Links” has changed unless they have some prior knowledge about the language.

But how do we describe this intra-linguistical knowledge in the language itself? We cannot say “All content units have …”, because “content unit” is not in the new language. Rather, we would have to state that “Fun Units and Fun Links have …” – but this requires updated semantic values to two strings from the alphabet. This might not seem like much, but by talking in a specific language we actually train parts of our brains to translate from this language into semantics (this was explained by Derek Smith at the Bristol Knowledge Unconference much better than I could explain it). This is an actual change to our brain that we are requiring – and we are requiring two changes in the new language.

To avoid this, we have added another string to the alphabet of our new language – “Ad Unit”. An “Ad Unit” can be a “Fun Unit” or “Fun Links” – but not both – so the interpretation of “Ad Unit” is the common interpretation between a”Fun Unit” and “Fun Links”.

But then if the semantics have remained the same between the two languages, the interpretation of “Ad Unit” must be the same interpretation as “Content Unit” was before…

That would mean that “Fun Unit” and “Fun Links” (both new words) are completely irrelevant words – since they don’t add any semantic information to the language!

Well, to explain this one we have to go back to the reason that we actually replaced the language in the first place. The first language  was defined by myself and Andy as we were thinking over the technical requirements, for use in implementing the systems. The second language came about after our sales and network teams mentioned that they thought users would get confused over the meanings of phrases.

We took this as a sign that we actually had two languages in use already – since there was obviously some concept that was essential to how this second group of people viewed the system that was not a concept to the technical team.

After some very long discussions, this concept had still not appeared to me, but the non-technical users described something that resembled the new language as describing their concepts better. This is a very interesting point to have come to in development terms – since it appeared to be a sign of what the users want to use the system to which is far better than anything that could be got out of a simple user-interview.

After hammering this out for several days, we finalised the new language. The above examples are only a small sub-section, but they are the section that cause the largest change in the allowed syntax of the language.

What was the difference?

Firstly let me quote the definition that the non-technical users decided on for “Fun Units” and “Fun Links” (I would have been far more strict over the definition, but if you’ve read this far then there’s a good chance that you would have as well; we may re-visit this definition):

• “A Fun Link is an Ad Unit into which the Viral Ad Network can place a link to site hosting an asset”
• “A Fun Unit is an Ad Unit into which the Viral Ad Network can insert actual content”

And that seems to be the difference – to me as a developer, there is a difference between the A,IMG,OBJECT,SCRIPT tags etc, – but that difference is contained in the selection between “Text Link”, “Text/Image Link”, “Video Player” (not mentioned previously) and “Gadget” (“Text” can only contain A tags, “Text/Image” can contain A and IMG tags, “Video Player” can only contain an actual video file, and “Gadget” can contain whatever you want).

For a non-technical user, really focusing on “this could be content” is more important – even though you could say that that information is already contained in the language, it’s so important that they want to say it twice.

Hence we’ve got the “old” and the “new” languages describing these things – the old language is cognitively simpler to learn, contains less vocabulary to learn, requires less mental work when new features are implemented, contains a single induced syntactic structure (at least over the vocabulary mentioned here) due to the orthogonality of semantic values, and does not require intra-linguistical “meta-knowledge” to talk about subsets of the language. It also has very low redundancy due to the

The new language has enforced redundancy, non-static syntactical structure, a larger vocabulary, non-orthogonal nouns, and thus has no strict subsets (when talking about Ad Units) that are languages capable of describing semantic updates in themselves. On the other hand, it focuses the mind on what the non-technical users found most important by repeating itself.

As you may have guessed, developers will continue to use the “old” language, and not just because switching over to the new language would require thousands of lines of code to be re-worked.

Tim Wintle

(oh, BTW, My definition of “viral” was brought here)

Update: YouTube appear to have listened to users’ comments, and made a second update in a day – the search box now only displays when you hover over the video.

Here’s what it looks like:

Click here to view the embedded video.

Understandably, many people might want to remove this “feature” – so here’s how:
(The YouTube api has been updated to mention this, so it appears to be a supported method)

1. In your embed code, find the url for the flash player (it is in there twice if you are using the standard YouTube embed code)
2. Add the parameter showsearch=0 (by adding “&showsearch=0″ to the url)
3. There is no step three – the video shouldn’t be showing the search box any more.

The video should now look like this:

Click here to view the embedded video.

Code:

<object classid=”clsid:d27cdb6e-ae6d-11cf-96b8-444553540000″ width=”425″ height=”344″ codebase=”http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=6,0,40,0″><param name=”allowFullScreen” value=”true” /><param name=”allowscriptaccess” value=”always” /><param name=”src” value=”http://www.youtube.com/v/4Cq4O_z5Blo&hl=en&fs=1&showsearch=0″ /><embed type=”application/x-shockwave-flash” width=”425″ height=”344″ src=”http://www.youtube.com/v/4Cq4O_z5Blo&hl=en&fs=1&showsearch=0″ allowscriptaccess=”always” allowfullscreen=”true”></embed></object>

I’m sure some people will find that useful when they look at their blogs today …

Tim W

I’d like to point out that I’m not following her process exactly in the images below…

Here’s what you’ll need:

Three Colours of Post-It notes

A very large piece of paper on the wall, or a large whiteboard

Stage 1:

Come up with a full list of use cases for your application (you do know you’re user’s use cases don’t you?). Pick a colour of sticky note and write them all down.

Stage 2:

Organise all of the the use cases into similar conceptual ideas on upper half of the piece of paper, so if two people are looking for statistics on a particular item (but for different reasons) then those two use cases would be in the same column. Move the columns around so that they each type of user’s use cases are close together.

When you’re finished this stage, you should have a piece of paper that looks something like this:

Stage 3:

Now choose another colour of sticky note and write down the features that your application currently contains. Stick these below the “tower” of use cases which they specifically fix.

Finally, time to do some brain storming over new features if you are in the planning stage, and write theses on the final colour notes (or if you’re in the middle of implementing a feature then put this on the final colour sticky note). Add these in the same way as before.

The idea of this all is to try to draw your attention to which use cases are being fulfilled by the existing system, and which parts may been more thought in the future.

You can also group the columns by the type of user that has those use cases (not shown on the image above). For example, in the above image we actually have five different groupings of use cases, and I’m glad to say that the section that appears to not have features to support it (just left of centre), is the group with only one user, Me, so it’s probably the least important section of the system to get up and running – I have my own external tools to support them.

I ran development buildout last night and suddenly saw a lot of zope 3 components being downloaded, which if you’ve done it before you know is a recipe for disaster.

It seems one of the new features in version 0.2 (aside from the long-anticipated browser layer support) is it now correctly defines its dependencies.  This is a Good Thing™ but it does mean that JBOT now requires you to use fake-zope-eggs in your buildout.

Your zope2install section now needs to look like this:

[zope2]
recipe = plone.recipe.zope2install
fake-zope-eggs=true
url = ${plone:zope2-url}

Not a big change, but it will cause Zope to advertise the packages it provides properly.  Incidentally, you also need to do this to try out plone.app.batch, a summer of code project that’s looking for comments for its demo.

Harald Armin Massa gave another great talk as an introduction to the 5 minute lightning talks – “Is Python ready for Enterprise” introduced the new module ncc1701.py (google code page):

(Sorry about the quality of the image)

Part of this code:

>>>import ncc1701

>>>p = ncc1701.Phaser()

>>>p.fire()

Traceback (most recent call last)

  File "<input", line 1 , in <module>

  File "ncc1701.py", line 86, in file

    raise PhaserNotLockedOnTarget

>>>s =ncc1701.Shields()

...

Despite the initial flaws, in the end we all saw that Python is indeed suited for controlling Enterprise applications.

At the end of the day Hans Rosling gave a very interesting keynote on the world’s economy using some very interesting interactive visualisation software designed for “people who are always being told what to do – young children and world leaders”. Here was one interesting slide:

“Where is child mortality highest?”

Yup, child mortality is higher in professors than in students, and almost as high as in Chimpanzees.

Developer:

“With Python, you have to write a tenth amount of the code as with C”

Why this is to be avoided:

“Less code means less programmers, less man-hours spent on your project, and a lower expenditure, which means that as a manager you will end up with a parking space further away from the office – stop it at all costs.”

I also went to two very interesting talks on PyPy, an interpreter for Python (and more) that would take more time to describe than I have now (and more than most would be willing to read through). It was great to be able to ask the developers some questions, and according to their first talk, we should expect production ready PyPy in between 6 and 12 months.

I also enjoyed the talk on “Building an App in a week” – a talk tailored at hacking together a django web site in very fast iterations – with some great tips, mainly under the heading “avoid doing work at all costs”.

If there is one slight problem I would complain about, it is that the wireless network here doesn’t seem to have been prepared for this many developers to all turn up at once with our IRC, email and ssh connections all running constantly during the talks. I heard one person complain that it was taking him 45 seconds to load the Google homepage – but amazingly Guido’s talk seemed to come through fine.

Signing off for now,

Tim

Stumbling upon this great blog post, I decided to run a task to render a Buddhabrot in glorious detail (6000X4000 pixels).

These images are released under a creative commons non-commercial share-alike licence (click the image for a low-resolution desktop background)

BuddhaBrot by Team Rubber / Tim Wintle is licensed under a Creative Commons Attribution-Non-Commercial-Share Alike 2.0 UK: England & Wales License.

Here is a close-up of the “head” of the brot (the part on the left) in it’s original resolution:

You can download the image scaled down to a desktop background, the high resolution image (not on the site to preserve bandwidth) is roughly 40Mb as a png.

For those interested, the intermediate data (passed between the map and reduce phases) was roughly 250 Gb of raw data. The mapper and reducer were both written in Python, with a single final reduce done off-cluster using PIL (the Python Imaging Library).

UPDATE

You can now download a torrent of the entire, full resolution image.

I’d like to thank my mother, father, my childhood pets, …