Ryan's Dev Blog

Peacock

2008-04-10T11:10:00.001+01:00

Peacock, originally uploaded by rjlothian.

Tulips

2008-04-10T11:08:00.001+01:00

Tulips, originally uploaded by rjlothian.

Robin

2008-04-10T11:06:00.002+01:00

Robin, originally uploaded by rjlothian.

Taken inside the Eden Project, Cornwall.

CRC algorithm

2008-03-20T21:44:00.002Z

I've written a CRC checksum generator in Haskell to complement my error detection/correction article.

My graph plotter

2008-03-19T11:20:00.001Z

I've finally got around to upgrading my graph plotter to work online.
You can play with the live demo at http://graph.ryanlothian.com/.

Review of OpenSuSE 10.3

2008-03-19T11:16:00.001Z

Is Ubuntu still king of distros? I took the plunge and installed OpenSuSE.

Read more

Tiger and duck problem

2008-03-19T11:14:00.004Z

A duck floats at the centre of a circular lake.

A hungry tiger waits a the edge of the lake, watching the duck.

The tiger can run four times the speed at which the duck can swim, but it can only go over land (i.e. around the circumference of the circle).

How can the duck reach the edge of the lake before the tiger and hence escape?

Need a hint?

A day at the zoo (photo)

2007-09-21T08:43:00.000+01:00

Canon EF 100mm USM Macro f/2.8
f/4.5 1/320sec ISO 400

A first look at Ubuntu Gutsy

2007-09-21T08:39:00.000+01:00

I've been trying out Ubuntu's latest alpha-release: Gutsy Gibbon (7.10). You can find screenshots and a log of my experiences with Gutsy on my website.

Ubuntu Edgy

2006-11-03T16:50:00.000Z

Ubuntu Edgy is now out. Release highlights include:

Firefox 2.0... which isn't really a huge improvement over 1.5.
a splash screen that doesn't work (at least for me)
Xorg 7.1
ATI drivers that are too old to work with Xorg 7.1 properly
a compile of MPlayer that complains about its compilation options every time your run it
more shades of brown and orange
etc.

It also has up to date software, like Edgy isn't bad though, worth upgrading if you don't mind a few hours of hassle. It fixes a few pesky bugs in Dapper, like not being able to change the frequency of my CPU's second core through the GUI. And having the latest things is always nice.

Kamaelia 0.5.0 Released!

2006-09-30T23:45:00.000+01:00

Kamaelia is an intuitive way to structure applications -- as a network of components which message each other. Much like Unix pipes implemented in Python. It was originally designed by BBC Research for rapid development of server software.

Here's a taster of what a Kamaelia application looks like: (built with the GUI)

And here's some equivalent Python code:

Pipeline(
  ConsoleReader(eol=""),
  SimpleHTTPClient(),
  SimpleFileWriter("downloadedfile.txt"),
).run()

Those 5 lines of Python give you a console-based HTTP downloading program (like wget or curl but with less options) using existing components.

the console reader sends lines of text (URLs) the user enters to...
the HTTP client, which fetches the associated page. It then forwards on the page data to...
the file writer, which appends all messages it's sent to a file on disk.

It's as simple as that.

Version 0.5.0 is a major release - lots of functionality has been added from Google Summer of Code 2006. Key highlights of this release:

BitTorrent support (using the official BitTorrent client) - includes preliminary 'streaming over BitTorrent' support. Lets you integrate P2P in your own Kamaelia applications.
HTTP client and nascent seaside-style pure-python webserver
OpenGL (e.g. the checkers/draughts board on the right)
Strong DVB (freeview TV) support on Linux - including the foundations of a PVR
Collaborative whiteboarding with audio (speex encoded) - draw and talk together over the internet
Visual composition of Kamaelia systems - create and link components on screen, see the code produced (the screenshot near the top of the article)

For more information see the Kamaelia website. You can get a copy of Kamaelia and Axon from Sourceforge, together with most of the dependencies in the mega bundle. If you have any problems or questions, just pop along to #kamaelia on irc.freenode.net. No Python experience is needed to get started!

Curse of BitTorrent strikes again

2006-09-25T00:11:00.000+01:00

Some oddness was noticed with my Torrent components after they were moved into the Kamaelia main tree - they no longer worked. TorrentTkGUI just sat there when started - it didn't even get as far as popping up a window. It turned out that BitTorrent expects a locale directory in ./ - a 'feature' added to the code base recently. We're now including the required English locale file where it is expected (as it is only 409 bytes) and considering removing the need for locale files as we only use BitTorrent for the backend.

Ubuntu 6.06 (Dapper) on my Inspiron 6400

2006-09-21T21:53:00.000+01:00

Ubuntu Dapper Drake is working very nicely on my new laptop. I had to install the ATI proprietary drivers manually as the ones in the repositories are too old to support my Radeon X1300. I have written some brief notes on how to setup Ubuntu on a Inspiron 6400. Now I can finally break my code on a true SMP machine :).

Efficient serving using flow control

2006-09-21T13:08:00.000+01:00

Generally, different parts of Kamaelia systems run at different throughputs. You may be able to read file faster than you can serve it to your clients (because they or you have slow network connections). They may not be able to decompress images at the rate they can read their data into memory. By slowing down data sources to reflect the rate at which later components can process/transmit that data, we can save a lot of memory.
Unpausing of components upon recipient.recv is due to be added to Axon in the next few weeks. This is very important for HTTPServer as it allows it to handle bottlenecks efficiently.
Three ways a file could be sent over a network:

Example A - without considering bottlenecks
FileReader ---> TCPClient -> -> (slow network) -> -> TCPServer
If the rate at which one can read a file from disk is faster than the rate at which the network can send (as it generally is), then the file ends up being stored in memory in TCPClient's inbox queue.

Example B - considering bottlenecks but without unpausing upon recv
RateAdaptiveFileReader ---> TCPClient -> -> (slow network) -> -> TCPServer

Now let us assume that we have a file reader that won't read any more from disk until the number of chunks of data in its outbox goes below a certain value. If the file reader pauses when its outbox length reaches this value, having nothing to do, it won't be woken when messages are removed from its outbox, so most of the file will never be read. Thus the file reader cannot pause, so it has to poll its outbox repeatedly. Polling is a bad thing - it uses large amounts of CPU unnecessarily. This is how HTTPServer currently works.

Example C - considering bottlenecks with unpausing upon recv
RateAdaptiveFileReader ---> TCPClient -> -> (slow network) -> -> TCPServer
As with Example B, except that the file reader can pause while it's waiting for the TCPClient to send stuff on. This is how HTTPServer is intended to be (and can be made to be with a few small changes).

HTTP server improvements and the release of GSoC 2006 work

2006-09-21T12:45:00.000+01:00

My HTTP and BitTorrent components produced for Google Summer of Code 2006 are now in Kamaelia's main tree (/Code/Python/Kamaelia/ in subversion).

I'm auditing HTTP server components for security and efficiency to get it past the 'toy' stage of development. So far, I've begun setting limits for request sizes (not POST body sizes, just header and URI sizes). I have also improved standards-compliance by converting HTTP version numbers to tuples of the form (major, minor). This makes comparisons much easier than if they were stored as strings.

I have also augmented the CharacterFIFO (character queue) class that originated in Chunkifier with a "popline" method, allowing it to be used in HTTPParser. This character queue replaces the old, inefficient concatenation methods that were previously in use.

Implicit pausing MiniAxon

2006-09-14T09:32:00.000+01:00

Consider a version of Axon where microprocesses pause by default after each iteration of main. Such a setup encourages the writing of efficient components by making polling difficult (but not impossible - a clock/tick threadedcomponent could send a wakeup message every second). This removes the ideas of pausing and unpausing - activate() can be used instead of unpause().

I also have different ideas about trigging the activation/unpausing of components. The component should be able to specify events that wake it. For inboxes, the receipt of a message could wake the parent component, or not. For outboxes, the removal of a sent message from the recipient inbox (through recv()) could also wake the parent.

There are occasions when you would not want delivery to an inbox to wake the component:
Consider this component:

class Combiner(component):
  Inboxes = ["a", "b"]

  def __main__(self):
      while 1:
          while self.dataReady("a") and self.dataReady("b"):
              newmsg = [self.recv("a"), self.recv("b")]
              self.send(newmsg, "outbox")
          yield 1

It waits until both inbox A and inbox B have at contain one message each, takes the first (oldest) message from each, combines them into a two-element list and sends that list on.
If A contains messages, but B contains none, the Combiner is waiting for B. The addition
of messages to A does not merit waking the component - it won't be able to do anything more than it could do before.

Syntax such as:

self.wakeOn("b")

could be used to accomplish this selectiveness.

BlitScheduler - a new approach to using pygame with Kamaelia

2006-09-12T12:16:00.000+01:00

Structure for blitting (using any 2d graphics library, but initially pygame):
- BlitScheduler component (which subclasses Scheduler) controls a single surface
- Visual components (e.g. line, sprite) are activated with a BlitScheduler component
- For each frame/refresh of the screen, BlitScheduler follows the following procedure:

1. Sort the visual components associated with it by z-order (so the backmost is first).
2. Send a message to the blit inbox of every visual component containing a reference to the shared surface (controlled by that BS)
3. Run the generator of each visual component in turn (by z-order)
4. Flip the surface (updating it to show the newly rendered surface).

Logo clone in Kamaelia

2006-09-10T11:15:00.001+01:00

I'm making a simple LOGO clone - eventually I intend to allow users to telnet to a shared display and command their own turtle. So far I have a single console-controlled turtle that understands LEFT, RIGHT, FORWARD and BACK, but no lines are drawn.

Dell Core2 laptops out

2006-09-01T22:49:00.000+01:00

Hurrah! Dell UK has finally started selling Core 2 laptops, just in time for me going to university. My new Inspiron 6400 should be with me in just over a week.

Mail server design considerations

2006-08-31T19:45:00.000+01:00

Creating a decent mail server is more difficult than it first appears. There are a number of issues which require consideration:

no mail that has been accepted should be lost if power is lost or the server is restarted
mail messages should never need to be kept fully in memory - they can reach many MB each
only one copy of each message should be stored on disc, regardless of number of recipients
the delivery of messages for remote hosts that cannot be delivered now (e.g. due to network problems) should be reattempted after a delay of a set number of minutes or hours
each message should get a unique id so it can be tracked by the administrator

Kamaelia mail server

2006-08-28T14:33:00.000+01:00

I have made a simple mail server for Kamaelia. Currently it can receive mail and store it but not forward it on. See /Sketches/RJL/SMTP/ in SVN.
The server's design follows the normal SimpleServer format except that each SMTPServer instance links itself to a shared QualityStorage component which handles saving messages (the 'quality' being that it confirms write-completition). A separate delivery component copies (hard links) messages into local mailboxes.

Mail server topology (when finished)

HTTP Spider

2006-08-24T18:31:00.000+01:00

HTTP Spider has been added to my catalgoue of Kamaelia examples.
Given an initial URL it downloads that page and then, by a breadth-first search, all pages that are linked to by downloaded pages. It can be limited to only download pages with a given prefix.

This example is fairly basic, not saving any pages to disc nor honouring robots.txt files, but it demonstrates the principal and could be adapted to look for 404s or to index a website for searching fairly easily.

Freeview on Linux (v4l-dvb)

2006-08-23T14:15:00.001+01:00

Up-to-date instructions for using a Freecom DVB-T USB stick on linux are now on my website.

I recently ordered a Freecom DVB-T (freeview) USB2 stick. Getting it working on Windows XP was fairly easy but Ubuntu was a different matter. These instructions also allow you to install v4l-dvb on Ubuntu if you have a different adaptor (but then you'll need to find the right firmware yourself).

(These instructions are for the UK only and are followed at your own risk.)

Plug in the USB stick then enter these commands to the terminal:


sudo apt-get install dvb-utils mercurial build-essential linux-headers-$(uname -r)
hg clone http://linuxtv.org/hg/v4l-dvb
cd v4l-dvb
hg update -C 4501
make
sudo make install

# if you aren't using the same adaptor as me, omit the next 2 lines
wget http://thadathil.net:8000/dvb/fw/dvb-usb/dvb-usb-wt220u-fc03.fw
sudo cp dvb-usb-wt220u-fc03.fw /lib/firmware/$(uname -r)/

sudo reboot

Note: the hg update -C ensures that you use a version of v4l-dvb that I know works (some later revisions do not work for me). At your own peril, omit it and so use the latest version.
Your USB stick's LED should be amber upon restart meaning it's working but not tuned in. I'm using Kaffeine as my player - open it now.

kaffeine

It should detect you have DVB and copy some files into your home directory. Now close Kaffeine.
Then you need to find the name of the transmitter nearest to you using WolfBane. I'll assume you are closest to Rowridge.

cd ~/.kde/share/apps/kaffeine/dvb-t/
cp uk-Rowridge uk-OriginalRowridge
nano uk-Rowridge

Round the frequency to 3 significant figures, e.g.

# Rowridge, Isle of Wight
# T freq bw fec_hi fec_lo mod transmission-mode guard-interval hierarchy
T 490000000 8MHz 3/4 NONE QAM16 2k 1/32 NONE

Now start kaffeine again, select uk-Rowridge (if that's your transmitter) and tell it to scan for channels. Add the channels it finds, close the scanning window and pick a channel. Your USB stick's LED should be green.

And that's all there is to it.

Bad ubuntu

2006-08-22T19:54:00.000+01:00

Ubuntu has been lax in its software testing - in the last few days it rolled out a broken X.org x-server package which renders PCs console-only upon reboot. Thinking it was something I'd done I spent some time trying old kernels etc. - eventually I found an article explaining the cause and solution (using apt to downgrade to an older version). Unfortunately another bug also cropped up as a result of this - Python/Tkinter no longer works. It gives an obscure error message about not knowing what colour "Black" is and dies. I finally tracked this down (with Google) to changes I'd made to xorg.conf while trying to fix it.

IOI and Exam Results

2006-08-22T19:47:00.000+01:00

I've returned from the IOI in Mexico, having had a great time. I gained the top Bronze Medal (only 1 mark off a silver!) which I'm quite pleased with. I also received my exam results when I got home.

A-levels:
Physics - A
Computing - A
Maths - A
Further Maths - A
ICT - A
General Studies - B

AS-levels:
Critical Thinking - A

STEP papers: (advanced mathematics papers)
STEP 1 - Distiction (1)
STEP 2 - Distiction (1)

And I also successfully completed a Cisco (CCNA 1-4) course.

I've achieved the grades required to get into university - studying Mathematics and Computer Science at Oxford.

Online documentation

2006-08-08T21:14:00.000+01:00

Online documentation for the Kamaelia components I've made is now available. These contain the doc-strings from the files they reference but also visual diagrams and links to other pages not possible in the plain text source-code files.

P2P Streaming Success

2006-07-31T13:24:00.000+01:00

The P2P streaming example I've been working on for Kamaelia is now in a working state. It allows any octet stream to be distributed automatically using the BitTorrent protocol. I have tested it over a LAN and it correctly shared and reconstructed my source stream in real-time.

Octet Stream -> Seed -> Swarm
Swarm <--> Peer

Though further testing is required, this approach could theoretically scale to thousands of peers per seed/tracker.

Proposed system for subcomponent flexibility

2006-07-26T09:30:00.000+01:00

Many Kamaelia components need to create their own subcomponents at run-time, e.g. my HTTP client spawns a TCPClient to connect to the server. However, this can cancel out much of the flexibility that a component-based architecture provides. As an alternative to hard-coding the class of each subcomponent, I propose that every subcomponent should be created from by a function provided as an argument at that components creation.

For example, in SingleShotHTTPClient:

def __init__(self, starturl, postbody = "", connectionclass = TCPClient):
...
self.connectionclass = connectionclass

And whenever a TCPClient was created in the old code, connectionclass is now called with the same parameters. The possibilities added by this are great:

for debugging, TCPClient could be replaced with a local console masquerading as a TCP connection.
TCPClient could also be replaced by a SOCKSTCPClient allowing it to go via a SOCKS proxy.
for logging purposes, connectionclass could be a wrapper function (rather than a class) that wrote the host addresses accessed to a file before spawning and returning a TCPClient
etc.

Most importantly, all these things could be done without having to change the code of HTTPClient.py. I propose that this practice should become standard.

Packaging and finishing touches

2006-07-20T20:26:00.000+01:00

I finally received the initial GSoC payment last week - thanks to Google for getting it sorted.
I'm working on packaging up my Kamaelia components - including the Torrent, HTTP, Util and IRC directories of /Sketches/RJL. Documentation is almost complete and I'm making the final touches to my components with a view to getting it all done by the first week of August.

Then, with some Python magic you'll be able to do the following to use my HTTPClient, as if it was part of the main-tree:

import Kamaelia.Community.RJL.Namespace
from Kamaelia.Protocol.HTTP.HTTPClient import SimpleHTTPClient

HTTP and streaming

2006-07-04T18:58:00.000+01:00

I've made some big changes to my HTTP code. HTTPParser no longer waits for the end of a response/request before sending information about it on - it now follows the format:

HEADER
BODYCHUNK
BODYCHUNK
...
BODYCHUNK
END

This allows memory to be saved and lower latency processing. As a result of this modification, my HTTP client now allows HTTP streaming.

My HTTP client has also been refactored to support this change - it is now split into a SingleShotHTTPClient which handles a single URL before terminating and a SimpleHTTPClient which uses the SSHC with a Carousel component to handle several requests one after another. I've also added a Kamaelia component called IcecastClient which can stream MP3 audio from a SHOUTcast/Icecast server. As the SHOUTcast protocol is almost identical to HTTP, this component subclasses SSHC.

Documentation will be my next focus.

TorrentService and TorrentPatron

2006-06-29T22:25:00.000+01:00

The MainLine BitTorrent client is unfortunately not thread-safe, even segfaulting in some versions if you try to run two instances simultaenously. In any case, several BitTorrent clients would likely be less efficient than one controlling several downloads/uploads. To work around this problem, I've made it so a single TorrentClient (TC) can be shared between several components. TorrentPatron (TP) should now be used in place of TC in all user code. TP is completely compatible with TC's input/output IPC messages but any number of TPs can be created without things breaking.

When a TP spawns, it checks whether a TS exists. If it doesn't find one, it creates a new one. Either way it then registers with the TS to use the 'service' that TS provides. This then allows TP to relay requests to TC through TS and receive them from TC through TS in turn. TS co-ordinates how the TPs are 'multiplexed' to safely use TC together.

IOI training weekend

2006-06-27T14:48:00.000+01:00

Last weekend I attended an IOI training session in Guildford. Six of us - the British team and the two reserves selected at the BIO - were invited, with food, travel expenses, and lodgings all provided. The event was generously hosted and funded by Lionhead Studios. We were programming in the the room where they keep their BAFTAs!
It was very educational and relaxed weekend. We got a lot of work done over the Saturday and Sunday - covering a large amount of algorithms material, and doing a fair few past competition questions. I hadn't been to a BIO training weekend before, as they haven't done them over the last two years, so this was quite an experience, and a very enjoyable one at that.

Google Package

2006-06-19T10:14:00.000+01:00

FedEx sent me tracking information about a package for me a few days ago. I received a pleasant surprise at about 8AM this morning - a notebook all the way from Google in California. I was barely awake so early, having been expecting it at around noon. The notebook has a nice black-blue covering (see right) - it's rather too nice to use. For now it's just for looking at.

TorrentClient

2006-06-18T15:04:00.000+01:00

I've added multiple torrent support to my TorrentClient component through a complete rewrite of its interface to BitTorrent. It now requires MainLine (official BitTorrent client) beta 4.9.9 but unlike previous versions requires no changes to its code. This means that it will work straight-away on any machine with BitTorrent 4.9.9 installed. I've done some light testing and it successfully downloaded two test torrents overnight.

Progress and TDD

2006-06-13T21:37:00.000+01:00

I have moved the HTTPParser component of HTTPServer to its own file. HTTP requests and responses are very similiar (the only major difference being the first line) so this allows some nice code reuse. As such, my new HTTPClient component also uses this parser component.

The BitTorrent-Kamaelia interface component now also works for those who have twisted installed.
I'm reading 'Test-Driven Development' - a book sent to me by the BBC (cheers!). It's a programming methodology that advocates writing automated tests and then code to satisfy those tests in that order rather than coding and then testing it.

HTTPServer fixed

2006-06-06T12:31:00.000+01:00

HTTPServer is now fixed - the charset issues have been resolved and it no longer uses 100% CPU all the time (thanks to changes to Axon and the Kamaelia TCP components). It also closes connections when appropriate. Kambot now allows timed reminders to be set which may prove useful.

Kamaelia Wiki

2006-06-02T16:38:00.000+01:00

I've started a Kamaelia Wiki that I (and others if they wish) can use to document Kamaelia and our Kamaelia-related projects.

Hurrah!

2006-05-31T13:40:00.000+01:00

For the last few days I've been trying to get Boost.Python examples to compile with no success whatsoever. After over an hour of messing about with Jamfiles, bjam and Jamrules (and all the other things that Boost decided they would require to compile a 12-line program) this morning, I chanced upon a page that gave the g++ commands needed, bypassing the ridiculously troublesome boost-build procedure.

Axon in C++

2006-05-29T16:45:00.000+01:00

Axon is the core of Kamaelia - the stuff that co-ordinates everything else, ensuring messages go from outboxes to their recipients' inboxes and running the components in turn. Kamaelia is primarily written in Python but there is proof-of-concept code for C++ in the CVS.
I've been creating my own (not-so-)MiniAxon in C++, focusing on efficiency unless it would overcomplicate the API. A Kamaelia implementation in C++ must provide much that the Python developer takes for granted. For example, Duff's device serves as a potent and yet intrinsically sinful implementation of generators:

#include <iostream>

static int generatorstate = 0, x = 1;
int generator()
{
  switch (generatorstate)
  {
  case 0:
     std::cout << "Hello World\n";
     generatorstate = 1; return 1;
  case 1:
     for (;;)
     {
        std::cout << x << "\n";
        x = x + 1;
        generatorstate = 2; return 1;
  case 2:
        std::cout << x << "\n";
        x = x * x;
        generatorstate = 3; return 1;
  case 3:
        ;
     }
  }
}

int main()
{
  generator();
  std::cout << "Run 1 time\n";
  generator();
  std::cout << "Run 2 times\n";
  generator();
  generator();
  generator();
  std::cout << "Run 5 times\n";
  generator();
  generator();
  generator();
  generator();
  generator();
  std::cout << "Run 10 times\n";
}

Character set woes

2006-05-28T15:39:00.000+01:00

I've found another bug in my HTTPServer - Python's character set support is horrid. Unfortunately, Python assumes that everything is ASCII by default, rather than a more sensible choice like UTF-8, and I've yet to get it to play nicely with Unicode. What's worse is that this bug only occurs when the IRC logs contain special characters:

UnicodeDecodeError: 'ascii' codec can't decode byte 0xc2 in position 19621: ordinal not in range(128)

What a nasty complication to an otherwise simple language!

I've made something nice to use for my streaming testing - a video of the swans at the local lake.

I'm playing around with Boost.Python, with an aim to wrapping libtorrent although I've yet to get the examples to compile!

Apt-proxy

2006-05-27T12:43:00.000+01:00

I discovered apt-proxy today. Like a standard HTTP proxy, it caches files (packages) requested, but as it understands that what it's downloading is for apt, it can intelligently delete out of date packages. Since I've got Dapper installed on 3 PCs now, this should save me a fair bit of time and bandwidth. Apt-proxy is running well on my old 500 MHz server (which has Ubuntu Breezy on it).

Metalink

2006-05-26T15:13:00.000+01:00

I found (or more accurately was pointed to) another cool possible basis for Kamaelia component - metalink. It's a download metadata format/system for grabbing parts of a download from multiple sources. For example, if your BitTorrent download is stuck at 99.2% then there's FTP mirrors you could try, or if the primary HTTP server for a file is slow you could grab bits from several mirrors. It's a good idea but I had some reservations - namely that you really should store hashes for parts of the file as well as the whole so that the correctness of each section can be confirmed, rather than having to start again if one byte was wrong. This is how BitTorrent checks the integrity of files. The author kindly sent me the Metalink 3.0 Draft Specification which I'm perusing right now. It's XML based and so easily extensible which is nice.

In other news, I've added a non-witty mode to Kambot (say "stfu kambot" to toggle it) to stop it from saying stuff during meetings etc. on #kamaelia.

And so it begins...

2006-05-25T18:08:00.000+01:00

This is to be my progress log for my work on Kamaelia for Google Summer of Code 2006. I'll be making a set of BitTorrent components for downloading and uploading files through BitTorrent, for making .torrent files and for moving .torrent files from A to B. The scope of my work is somewhat wider than just BitTorrent however. I've made a basic but effective HTTP server and an IRC logger bot for Kamaelia so far.
I'm currently experimenting with using SWIG to wrap C++ modules for Python.

HTTP Benchmarking

2006-05-22T18:28:00.000+01:00

Benchmarking my HTTP server revealed some issues - I was not closing components after their TCP connection closed. Initially I was getting throughput of about 5 hits/sec. After some tweaks, such as only yielding when left with nothing to do, I managed to get 100 hits/sec for highly dynamic pages or 800 hits/sec for small static pages when using persistent connections. This is fairly good, although an simple, efficient webserver written in C could probably handle several thousand hits/sec. I've been using siege to do the load testing/benchmarking.

I found a bug in the Kamaelia TCP components - they raised an exception when the remote host disconnected unexpectedly, taking down the entire HTTP server in the process. :D

I've made a handy little Python script to convert tabbed code to spaced code.

#!/usr/bin/env python
import sys, string

def tabsToSpaces(path):
   myfile = open(path, "rb")
   contents = myfile.read()
   myfile.close()
   lines = string.split(contents, "\n")
   contents = []
   for line in lines:
       tabs = 0
       replacement = ""
       while line[tabs:tabs+1] == "\t":
           tabs += 1
           replacement += "    "
       contents.append(replacement + line[tabs:])
      
   contents = string.join(contents, "\n")
   myfile = open(path, "wb")
   myfile.write(contents)
   myfile.close()

if __name__ == "__main__":
   if len(sys.argv) != 2:
       print "Usage: tabsToSpaces.py "
   else:
       tabsToSpaces(sys.argv[1])

Dapper Drake - First Impressions

2006-05-20T18:33:00.000+01:00

I've upgraded to Ubuntu 6.06 (Dapper Drake) beta and I have to say I'm fairly impressed on the whole. The upgrade procedure from 5.10 was very simple - modify your apt sources.list to say 'dapper' where it previously said 'breezy', then run apt-get update and apt-get dist-upgrade. It's a lot less troublesome to get setup than Fedora Core 5 was, although I'm only using the x86 version of Ubuntu rather than AMD64 as I did with Fedora.

I was having a minor problem with colour (#fcfcfc would appear considerably darker than #f0f0f0) but the new nVidia drivers (available through apt in Dapper) fixed it. I also had problems on an older Pentium II machine - everything after grub and before the login screen is garbled most likely due to buggy ATi drivers (it's a All-in-Wonder based on the Radeon 7200). I'm considering going back to Breezy on that PC.

sudo dpkg-reconfigure gnome-applets fixed the CPU applet (after the upgrade it was no longer SUID so you couldn't pick a frequency. The gnome-art package is great for customising the appearance of Gnome.

It also has Firefox 1.5, gstreamer-0.10 and a working mplayer package and Eclipse C++ support which were some of the main things I wanted, seeing as I had them on Fedora Core 5 before.

In summary, Dapper is better than any Linux distro I've seen before, but only by a little. Its default colour scheme (brown and orange) is hideous but the other colour schemes don't look as modern. Legacy ATi support needs work - I've seen similar problems reported on the Ubuntu bug tracker. The games, as with most Linuxes, are pathetic. They are of no comparison to the majority of commercial games. That said, if I wanted my PC primarily for gaming, I'd be using Windows XP Home Edition...

All up and working again

2006-05-19T18:38:00.000+01:00

My new graphics card (an Asus nVidia 6200 AGP) arrived and my computer is working fine again thanks to it. It's also passively cooled - there has been a noticeable drop in the PC's noise level. Though it's not as powerful as my broken 6600GT was, it was a good buy at £35.
For your information, the faulty component was an XFX product - I will be avoiding them at all costs in the future.
HTTPServer is coming along. I've added better support for complex URLs.
I've also tied it to the IRC logger successfully.