Dominic Orchard's Personal and Computer Science Blog

2009-07-29 - Curious: Google link colour

Dominic Orchard — Wed, 29 Jul 2009 11:48:16 +0000

After this morning's first Google search, I had a feeling that something looked different, glitch-in-the-Matrix style. The blue colour of the links looked different to how I remembered them; the links just looked brighter, and honestly, a little tackier. For a moment I thought it was just my eyes or my imagination but then I looked into it.

Currently (for me in the UK at least) the CSS for the link colour is:

.link{color:#3600f4!important}

I had a bit of a search and I found a blog post from earlier this month stating Google uses colour #2200CC for its links. Apparently Google engineers tested a variety of hues with varying levels of blue and green and found a bluer colour encouraged users to click-through more than a slightly greener hue of blue.

So, let's compare the ostensible previous colour #2200CC with the one I am seeing now:


#3600f4	#2200CC
New	Old

The higher level of red and blue in the new link colour creates a brighter, slightly purple hue. Perhaps Google is experimenting randomly with me to see if I click through more on this new colour? I would be interested to hear if anyone else is seeing this colour too.

To check in Firefox go to the "View" menu, click "Page Source", and then do "Edit" -> "Find", search for "link" and you should see something like .link{color:#3600f4!important}. Then post the code for the colour. For Safari, or IE users, I don't know the procedure, but for IE I think you need to do something like right clicking and choosing "View Source".

Good interface design applies the concept of "affordance" to interface elements - essentially, whether an element's appearance indicates to the user how to interact with it. This concept relies on some kind of experiential world knowledge e.g. buttons are raised elements that look like they can be pushed down so that they are flush with a surface. For the frequent internet-user, the blue text of a hyperlink is part of their discourse. A blue hyperlink is highly associated to visiting a new page due to its frequent usage ever since early hypertext browsers.

However, whether changing the link colour of Google search results alters the click-through rate is a different issue. People expect there to be links on the search page, so even if they were red or green I believe they would still know what to do, and click on them. Google's hypothesis then must be that the blue-ish colour stimulates a conditioned behaviour, a kind of Pavlov's Dog effect for blue links.

Either way, these slightly purple Google results just look a little too garish for me! Here's what a search looks like now for me compared to what it would look like with the old colour:


New	Old

What's crazy is that I'm so used to the bluer links I spotted the change immediately. Time to spend more time outdoors I think....

29 July 2009 11:48:16 - General | Comments (6)

2009-05-18 - Morning Bride

Dominic Orchard — Sun, 17 May 2009 23:08:56 +0000

So last week I went to a very different, and very fun, gig at Saint Mary's Old Church in Hackney. Picture a small, beautiful, 500 year old church, with old-school pews (that are very tall and have doors!), lit with candles, and bursting with some great live music.

The brilliant Morning Bride [myspace] were headlining. I have the privilege of living in the same house as their cellist, Alexa, who provided me with the motivation to go along. They played a fantastically lively and beautiful set - do check them out!

I also particularly enjoyed one of the support acts: The Gadjo Form, whose style, in their own words, "lies between traditional gypsy and east european folk". This provided for some great crazy dancing!

A great show and a great night- thanks Alexa for inviting me along!

17 May 2009 23:08:56 - Music | Comments (2)

2009-05-13 - Blog split

Dominic Orchard — Wed, 13 May 2009 18:30:04 +0000

The separation of life and geekdom

I had the realisation the other day that I had become reluctant to post computer science blog entries at the risk of annoying any non-computer science readership, and dually had become reluctant to post personal, or miscellaneous, blog entries at the risk of diluting any computer science content. This dichotomy of reluctance resulted in little to no blogging. The solution? Two blogs.

I now have a personal blog for essentially everything, and a computer science blog for maths/computer science and research-type things. Subsequently there are also two separate feeds and a feed that combines both. The old RSS feed address points to the feed for both blogs (see the pane on the right for the choices).
Hopefully now I will be encouraged to blog more, both personal and miscellaneous items that take my interest, and on computer science. I also have the ability to make a post that goes to both blogs (like this one). Hurray!

Accompanying this split is a slight revamping of fonts and layouts, and a fixing of the older posts that had broken layouts.

13 May 2009 18:30:04 - General | Comments (8)

2009-04-29 - Easter and BCTCS '09

Dominic Orchard — Tue, 28 Apr 2009 23:14:27 +0000

Apologies for the lack of blog posts over the last few months. I've been pretty busy, but also quite lazy in writing anything on here, even if just to say that I am alive and well. It is now the "summer" term here at Cambridge and I am hoping that it will be a productive one.

I had a full and fulfilling Easter holidays: attending the Midlands Graduate School (a week long pedagogical conference aimed at graduates doing theoretical CS work with programming languages), attending BCTCS 2009 (British Colloquium for Theoretical Computer Science), briefly visiting my family, and taking a trip with friends to Germany to see our good friend Larry (fantastic).
It was a brilliant way to spend 3 weeks over Easter!

BCTCS '09 was held at Warwick University- the university that I graduated from just last year and that is very dear to me! I enjoyed the conference particularly as I got to spend time with Steve Matthews and Sara Kalvala (my undergraduate project supervisors from my 3rd and 4th years), old friends from my undergraduate days, new friends from other universities, and also Bill Wadge, co-creator of Lucid, who was invited to speak at BCTCS '09 all the way from Victoria, Canada.

If you have ever had a conversation with me about computer science you will know I have a particular proclivity for the Lucid programming language, so getting to chat about all things Lucid for a few days was great fun. Bill supervised Steve back when Bill was at Warwick, in the early days of Lucid. The quip is that Bill is my grandsupervisor.
The Lucian language is my own object-oriented hybrid of Lucid. I started Lucian as my 3rd year project and dissertation- quite some time ago now. The ideas developed further after discussions with Bill back in 2007, resulting in Steve and I publishing a paper which came out last year. In January 2009, with the BCTCS looming, I thought it would be fitting to talk about Lucian at BCTCS, due to Bill and Steve being present, and BCTCS being held at Warwick, the crucible of Lucid's youth. So I revisited Lucian and discovered that there was much more to say than was originally conveyed in the paper. I mulled Lucian over last term and have since revised the language and have had some further thoughts about its semantics.

I include here the slides from the my BCTCS talk. I am planning to write a few blog posts on Lucid, Lucian, and some other ideas and thoughts that came out of discussions at BCTCS, so watch this space if you are interested.

Regular blog posting: a promise so easily made and so easily broken.

28 April 2009 23:14:27 - Lucian | Comments (9)

2009-02-19 - Boston Globe article on computational intractability

Dominic Orchard — Thu, 19 Feb 2009 13:24:25 +0000

Something for the non-math/non-compscis out there.

Over dinner last night I briefly talked about intractability and the P=NP question with a non-computer scientist friend. This morning I discovered, whilst wading through a bunch of blogs that I read intermittently, a recent news article from The Boston Globe that gives a nice, general introduction to the idea of computational intractability. The article is online here. Here is a quote:

"We know answers exist, but it turns out that calculating the solutions to such kinds of problems could take too long, even if all the world's most powerful computers were to work together on them. Individual instances can be solved, but there is no general way to attack such problems efficiently, which means the "universe could have degenerated into black holes while your computer is still running," said Scott Aaronson, a theoretical computer scientist at MIT."

19 February 2009 13:24:25 - General | Comments (1)

2009-02-18 - The Koch Snowflake

Dominic Orchard — Wed, 18 Feb 2009 09:35:03 +0000

Construction and some properties

As I mentioned a couple of weeks ago I was going to write a post about a certain fractal. Now I have finally gotten round to writing something it has come at a very appropriate time as Britain has seen an unusual amount of snow recently. Sadly all of that snow has melted now. I am going to briefly introduce the Koch Snowflake (also known as the Koch Island, or Koch Star) which is a fractal with a very simple construction. I will first informally describe a geometrical construction of the fractal and will then show some of its properties, particularly the property that the fractal has an infinite length enclosing a finite area.

Construction
The base case of the construction is an equilateral triangle. For each successive iteration the construction proceeds as follows:

Divide each edge of the polygon (say of length a) into three equal segments of length a/3.
Replace the middle segment with an equilateral triangle of side a/3.
Remove the base edge of the new equilateral triangle to form a continuous curve with other line segments.

Thus each edge is transformed as such:

The first 5 iterations look like:

Properties
Two properties of this fractal may seem paradoxical at first but are easily shown. I will show the derivations here for the interested without skipping too many steps.
For an infinite number of iterations the perimeter of the fractal (the length of all the edges) tends to infinity whilst the area enclosed remains finite.

Infinite Perimeter
First consider the number of edges for an infinite number of iterations. Initially the number of edges is 3, each iteration transforms a single edge into 4 edges (see above), thus the series of the edge count is: 3, 12, 48, .... The general form is:

Starting from an edge length of a each iteration divides the edge length by 3. The following defines the edge length for iteration n and from this calculates the perimeter for iteration n. The limit as n tends to infinity is found, showing that the perimeter is infinite.

Thus it is easy to see that the perimeter length is infinite through standard results on limits.

Finite Area
The area calculation is a little bit more involved. The result can be seen on Mathworld or Wikipedia but a full derivation isn't given, so I show my derivation here for the interested.

The area of the n-th iteration of the Koch snowflake is the area of the base triangle + the area of the new, smaller, triangles added to each edge. From the above length calculations and construction we know that each iteration of the construction divides the length of the edges by three. First consider the relationship between the area of a triangle of edge length a and a triangle of edge length a/3

Unsurprisingly we see that dividing the edge length by 3 divides the area by 9.
At each iteration we add new equilateral triangles to each edge, a ninth of the area of the previous iteration's triangles. We formulate this as a summation of base case A0 plus the next n-1 iterations where the triangle area at each stage is A0 divided by 3²ⁿ or 9ⁿ (successive divisions of the area by 9). The number of edges is defined by the previous iterations number of edges 3 * 4^n-1, thus at the n-th iteration we need to add this number of triangles to the snowflake.

Thus the area is finite at 8/5 times the area of the base equilateral triangle.

Summary
So the Koch snowflake construction has been introduced and it has been shown relatively easily that the area of a Koch snowflake tends to a finite limit of 8/5 times the base case area (5) and that the length of perimeter tends to infinity (4). Next time I will probably talk a bit about the fractal dimension of the Koch snowflake and also show an interesting problem that uses the Koch snowflake.

As a last note, following on from the blog post I made about the Python turtle library, a turtle program of the Koch snowflake for Python can be downloaded here.

18 February 2009 09:35:03 - Maths | Comments (7)

2009-01-25 - Girl with violin

Dominic Orchard — Sun, 25 Jan 2009 17:46:10 +0000

25 January 2009 17:46:10 - Art | Comments (4)

2009-01-23 - Fractals with the Python turtle library

Dominic Orchard — Fri, 23 Jan 2009 01:12:18 +0000

Y-fractal

This coming weekend I am planning on writing a blog post about a particular fractal (I won't give the game away just yet :p), and whilst looking around at what was written on the Internet about this fractal I stumbled across a really cool little Python library: turtle. The turtle library essentially provides LOGO-like functionality to Python. You get a nice turtle object on which you can call standard logo functions like forward, left, right, pen up, etc. and it draws them on a Tk widget for you - FUN!
I thought I'd just share a couple of simple programs I made using the turtle library. The next post I will make about fractals will be more mathematical - this post is just for fun.

I show here a method of drawing Y-fractals using the turtle. The informal scheme for drawing Y-fractals is: draw a Y then at the end of each of the two top branches of the Y draw smaller Y shapes and so on... A simple way to define fractals is via a Lindenmayer system which is essentially a grammar of production rules, variables, constants, and starting axioms. My Y-fractal has the following L-system properties:

Constants:
- L : Turn left 45 degrees
- F : Move forward 100/1.6^i (where i is a scaling factor)
- S : Increment scaler i
- A : Turn 180 degrees
- T : Decrement scaler i
- K : Turn left 90 degrees
Rules : A -> LFSATFKFSATFL
Axiom (Start) : A

The single rule "A -> LFS.." gives an ordering of constants which controls the turtle (incidentally as a quick cheat A is used here as a variable for the main rule and as a constant). Repeated rewrites of the start sequence "A" based on the rule "A -> LFS..." defines the fractal up to a particular finite depth. You can follow the instructions yourself on paper and see that this works. Here is the Y-fractal being drawn upto a branching depth of 5:

Y-fractal with branching depth of 5 in the process of being drawn by the Python turtle library.
Download the source file for this program

The neat thing about the library is that it handles all the graphics for you, so you can just have fun. The above example is only 20 lines of code:

import turtle

# Position the turtle
turtle.up()
turtle.goto(0,-100)
turtle.left(90)
turtle.down()

# Create description of the fractal
set="A"
for i in range(5): set=set.replace("A","LFSATFKFSATFL")

i = 1
turtle.forward(40)
for move in set:
    if move is "A": turtle.left(180)
    if move is "F": turtle.forward(100.0/1.6**i)
    if move is "L": turtle.left(45)
    if move is "K": turtle.left(90)
    if move is "S": i+=1
    if move is "T": i-=1
input()

Simple! The for-loop performs the L-system rewrite 5 times to create the 5 branches of the fractal. I then took this simple program a bit further and created a program that varies the branching factor and length of branches over time, generating a set of frames that emulates a tree growing from a small sapling to a densely foliaged tree:

Apologies: The Youtube video is pretty blurry; the AVI file is slightly clearer although for some reason I still lost quite a bit of clarity from the generated frames. Here is the source file for this program (and the supporting script files used to convert the PS files to PNGs, generate still frames for the start and end of the movie, and convert from a sequence of PNGs to an AVI).

So if you want to reminisce about the good old days of programming LOGO on your school's 286 during lunchtime then have a play with the turtle library, it comes with standard Python 2.4 and 2.6 installs.

23 January 2009 01:12:18 - Programming | Comments (3)

2009-01-22 - Submitting to the world of instant updates....

Dominic Orchard — Thu, 22 Jan 2009 01:03:54 +0000

Twit-twoo

So I finally gave in and started using that Twitter account that I once registered for. I'm thinking that it could provide a further means for me to structure, and account for, my day-to-day research: what I am reading, what I am thinking about, what talks/conferences/etc. I am going to, and what I am doing. This is assuming I remember to update it.

I suppose I want to do this mostly for my own benefit, but it could also provide a way of publicising computer science research for fellow computer scientists and polymaths at all levels - in academia or otherwise. Anyway... I added a Twitter widget to the right-hand pane of this site showing my latest 3 updates.

Hope everyone is well. Dom.

22 January 2009 01:03:54 - General | Comments (4)

2009-01-09 - Doodle - Dr. Wikipedia

Dominic Orchard — Fri, 09 Jan 2009 10:05:36 +0000

I know the whole "Wikipedia-joke" is a bit old - I apologise! This doodle does not come from personal experience but a conversation I once had with someone about the use of Wikipedia in medicine.

9 January 2009 10:05:36 - Doodles | Comments (5)

2008-12-24 - Doodle - Animal Farm on office safety.

Dominic Orchard — Wed, 24 Dec 2008 22:10:52 +0000

Once again this doodle requires some prior knowledge for it even to be comprehensible, let alone funny. This time its Animal Farm by George Orwell. Sorry. Happy Christmas all!

24 December 2008 22:10:52 - Doodles | Comments (8)

2008-12-15 - We by Yevgeny Zamyatin

Dominic Orchard — Mon, 15 Dec 2008 00:33:28 +0000

Book recommendation

Time for another book review folks. This time it's a Russian dystopian science-fiction classic - We by Yevgeny Zamyatin. I discovered this book a couple of months ago when browsing a bookstore and was surprised that I had never even heard of it. I finally decided to write a quick review for anyone else who hasn't heard of it. I read the 1993 English translation by Clarence Brown. I thought it was brilliant, but having read just the one translation cannot compare it to other translations.

Written between 1920 and 1921 We has a history that is an interesting story in itself. It was banned from publication in Russia, due to its controversial political content, and was first published in English in New York, 1924. It wasn't until 1988, towards the end of the Soviet Union, that We was finally published in Russia, although a Russian version was released in America in 1952. There were numerous translations prior to the Russian release in 1988. Author's working from illegal copies of the original manuscript took extra care to make it appear as if they had translated from another translation so as to protect Zamyatin, who was already in trouble over the appearance of foreign editions.
George Orwell has acknowledged that We provided much inspiration for 1984, which Orwell wrote in the late 1940s. We also predates Aldous Huxley's Brave New World, although this was written without any knowledge of We.

Written in a prose poem style We is a set of "records" written by D-503, a mathematician of OneState, and builder of the INTEGRAL space ship. D-503's records, written in the 26th century, are addressed to future readers from a different planet and culture. OneState is a city, and a society, that has emerged after a 200 year war that wiped out the majority of mankind. To ensure the happiness of man OneState fiercely restricts the freedom of the people, controlling day to day life via "The Table"; meal times are set, work times are set, even sex is programmed. Men have become as machines and are as such happy. At the outset D-503 is completely devoted to OneState and its goals, revelling in the perfect mathematical precision and admonishing the savagery of the past. However as the records progress we see D-503's world shattered as he struggles to hold on to his devotion to OneState and is pushed to edge of his reality by involvement with a woman numbered I-330.

The writing is brilliant. At times it is poetic, littered with playful metaphors, at other times it is fractured and incoherent, reflecting D-503's fevered train of thought as he questions his world. The writing style alone makes it immensly enjoyable, and the story is compelling and thought provoking. I strongly recommend this classic to anyone!

We
Yevgeny Zamyatin

Image from Amazon.co.uk

Find this book on:

15 December 2008 00:33:28 - Books | Comments (10)

2008-12-09 - OpenCL 1.0 Specification released

Dominic Orchard — Tue, 09 Dec 2008 20:27:06 +0000

Some thoughts...

Yesterday the specification for OpenCL 1.0 was released. For those who don't know what OpenCL is here is a summary quote from the specification:

"OpenCL is an open industry standard for programming a heterogeneous collection of CPUs, GPUs and other discrete computing devices organized into a single platform. It is more than a language. OpenCL is a framework for parallel programming and includes a language, API, libraries and a runtime system to support software development. Using OpenCL, for example, a programmer can write general purpose programs that execute on GPUs without the need to map their algorithms onto a 3D graphics API such as OpenGL or DirectX." [p. 18]

A worthy goal. But is OpenCL designed for use by anyone?

"The target of OpenCL is expert programmers wanting to write portable yet efficient code. This includes library writers, middleware vendors, and performance oriented application programmers. Therefore OpenCL provides a low-level hardware abstraction plus a framework to support programming and many details of the underlying hardware are exposed." [p. 18]

What about the general scientific computing community? Do we expect them to be expert programmers or have expert programmers on hand to write their simulations?
While OpenCL addresses the expression of low-level programs for compilation to heterogeneous architectures it does not solve the human-tractability issues of manual parallel programming: it is complex, lengthy, tedious, error prone, and difficult to prove.
OpenCL is not all things to all men/women. It does however provide a possible intermediate language for higher-level languages that abstract over low-level concurrency/parallel concepts.

An interesting issue, that the specification picks up on, is that heterogeneity makes portability difficult when to porting code between a CPU and a GPU (as opposed to between different types of CPUs and different types of GPUs).

"Unfortunately, there are a number of areas where idiosyncrasies of one hardware platform may allow it to do some things that do not work on another. " [p. 208]

"Likewise, the heterogeneity of computing architectures might mean that a particular loop construct might execute at an acceptable speed on the CPU but very poorly on a GPU, for example. CPUs are designed in general to work well on latency sensitive algorithms on single threaded tasks, whereas common GPUs may encounter extremely long latencies, potentially orders of magnitude worse. A developer interested in writing portable code may find that it is necessary to test his design on a diversity of hardware designs to make sure that key algorithms are structured in a way that works well on a diversity of hardware. We suggest favoring more work-items over fewer. It is anticipated that over the coming months and years experience will produce a set of best practices that will help foster a uniformly favorable experience on a diversity of computing devices." [p. 208]

This doesn't sound like the behaviour of a language with which people want to write "portable yet efficient code." [p. 18], but it is not the fault of OpenCL. This particular lack of portability is a necessary symptom of the low-level nature of the language. In OpenCL a loop is a loop. How can this be solved? Ideally we don't want our programmers to have to modify their algorithms to suit a set of possible hardware. Ideally algorithms and implementation should be separated by layers of specialization.
A more abstract language may describe a loop that has a semantically equivalent efficient interpretation for a GPU and a standard efficient interpretation for the CPU. However, it is not desirable that a compiler perform significant transformations unbeknownst to the programmer, as this affects the programmer's (tacit or otherwise) cost-model for the language.
Perhaps specializations should be expressed by the programmer (up to a point) via a multi-tiered approach to programming languages? Who knows! I'm just waving my hands in my head now and am going home for some tea. Check out the OpenCL project if you are interested.
Bye.

9 December 2008 20:27:06 - Programming | Comments (14)

2008-11-23 - Einstein and Eddington

Dominic Orchard — Sun, 23 Nov 2008 14:16:55 +0000

I just watched a brilliant drama on the BBC entitled Einstein and Eddington telling the story of Albert Einstein's formulation of General Relativity and its confirmation by British scientist Arthur Stanley Eddington around the time of World War 1. Plenty of details are elided and I am sure certain aspects are not entirely factually accurate but nevertheless this is a very interesting, wonderfully acted, and engaging portrayal of both scientists and their respective struggles against their peers in a politically charged climate.

Watch it on the BBC iPlayer if you can!

23 November 2008 14:16:55 - Science | Comments (11)

2008-11-08 - Another busy week...!

Dominic Orchard — Sat, 08 Nov 2008 14:01:30 +0000

It's been another crazy (but very enjoyable) week for me. Tuesday was of course the night of the US election. I nearly went to bed as I'd been at a formal dinner with all the computer science students at my college and then to the cinema to see Quantum of Solace (which I highly recommend by the way). So by the time I got home at about 12:30am I thought I might just go to bed, then I came to my senses are realised that it would be great to witness this historical election live and to share in the experience with my friends. So I went down to the Cambridge Union with some friends and stayed up until Obama's acceptance speech -around 5am for us! There were so many students down at the Cambridge Union all night- joining in, cheering, and celebrating the final outcome. It was great to be part of it! I attemped to take a photo from the balcony with my phone, sadly it was too dark for my phone to capture the scene properly.

This week it seems I have done more talking and discussing than reading- but that's probably not the end of the world as some nice ideas have been forming about structured grid programming this week- especially yesterday- but I won't divulge anymore at the moment.
One thing I have noticed recently is that every week I somehow end up having a conversation with someone about Lucid or my work with Lucid. It seems that there are still a few people around who are interested in this gem of a language!

On another note: I have removed the doodles from this blog and moved them into their own section in an attempt to keep my blog a bit more serious and free from my unfunny and bizarre doodles! I have posted a new doodle this weekend.
See you all later, Dominic.

8 November 2008 14:01:30 - General | Comments (3)

2008-11-08 - Doodle - That's what she said...!

Dominic Orchard — Sat, 08 Nov 2008 13:21:34 +0000

The inspiration for this weekend's strip comes from a hilarious conversation had between Chris, Gregg, Max, Milos, and I during happy hour in the Computing Lab last night.
Again apologies: this edition is probably the MOST obscure so far- sorry!

8 November 2008 13:21:34 - Doodles | Comments (3)

2008-11-01 - Doodle - Venn Diagrams

Dominic Orchard — Sat, 01 Nov 2008 13:13:29 +0000

(Walking \cap Social Engineering) = Tailgating

This little doodle is based on a bizarre late night conversation between James Willmoth and I. Hope you like it Jim!

1 November 2008 13:13:29 - Doodles | Comments (2)

2008-10-30 - Why C and FORTRAN and not Haskell?

Dominic Orchard — Thu, 30 Oct 2008 19:51:06 +0000

Yesterday I attended the Many-core Computing workshop at Cambridge organised by a group of researchers at Cambridge University who are using many-core devices (such as GPUs) to accelerate their scientific applications. There were a few nice presentations showing the latest techniques that people are employing for fast computation using hardware such as the NVidia Geforce 8 Series and 9 Series cards, and using tools such as CUDA, writing simulations in C.
I went along as my current main research interest is the development of compilers, language extensions, and languages for parallel programming- especially those targeted at many-core architectures. I am very interested in the Data Parallel Haskell extension for GHC, which facilitates data parallell programming in Haskell. There is a good chance I will be devoting a reasonable amount of time to this system in my research, hence at the workshop I spent a lot of time thinking, "How can we get these guys using Haskell?" and "Would these guys EVER use Haskell?" The workshop made me see how attached the scientific community are to C (and sometimes to FORTRAN), and I've been trying to ascertain why? Any suggestions? Here are some possibilities:

They were brought up, or educated, using procedural/imperative languages.
There are extensive libraries available for C.
There is a very short learning time to using these languages.
They like the constructs- the array handling, re-assignment, statements, side effects, and global variables?
Imperative semantics and constructs fit our default mental model of the world better than those of functional programming? [Is this true... maybe...]

Or all of the above? I had a really interesting conversation with Nick Maclaren at the workshop about various languages topics and how people like FORTRAN because of the first-class arrays and overloaded arithmetic operators for arrays. Maybe we need to make our functional array syntax and constructs better!

Anyway... so apart from these things I had a silly idea the other day for a humorous little comic and just quickly doodled it out. I will post this in a separate post that will appear below:

30 October 2008 19:51:06 - Languages | Comments (3)

2008-10-30 - Doodle - PeArl and CamEl

Dominic Orchard — Thu, 30 Oct 2008 19:37:28 +0000

Revenge of the vowels

I almost did a "sea" joke... aren't you glad I didn't!
For the non-computer geeks out there: there are two reasonably popular programming languages called Perl and Caml. The "fun ride x = ... " is a fragment of possible Caml code. Now you get it!!! I did actually see the word "pearl" in type the other day and thought to myself momentarily, "That's an odd spelling... oh.", and subsequently realised how much of a geek I am.

30 October 2008 19:37:28 - Doodles | Comments (8)

2008-10-25 - Catastases

Dominic Orchard — Fri, 24 Oct 2008 23:51:12 +0000

3 weeks of PhD done so far.

So I have been doing my PhD for 3 weeks now and am really enjoying it. It's a great feeling to finally get to read and enjoy all the things I have been keeping on the back-burner until now.

At Cambridge there are so many great opportunities to meet some very smart people and to attend some really excellent talks on a range of topics. I may at some point post some links to some of the research topics I have been reading and hearing about in the last 3 weeks. So much stuff to learn- so little time!

This doodle is an approximation of me at my desk.. thinking about the construction of existential types in Haskell via the "forall" type quantifier - and the Curry-Howard isomorphism proof of its construction [forall a. (a -> K) = (exists a . a) -> K].

24 October 2008 23:51:12 - Doodles | Comments (4)

2008-10-02 - Diaspora by Greg Egan

Dominic Orchard — Thu, 02 Oct 2008 15:39:48 +0000

Book recommendation

This brilliant hard science fiction novel by Greg Egan is as much gripping as it is intelligent and thought-provoking. Egan combines transhumanism, consciousness, multiverses, extra-dimensional theory, wormholes, astrobiology, computational equivalence, and much more, into a rivetting tale of the human race's search for immortality. The book begins in the year 2975. The human race has split into three factions: fleshers- what is left of homo sapiens, Gleisner robots- simulated human brains running inside of humanoid robots, and polises- supercomputers hosting millions of consciousnesses, free from any physical restrictions within their own simulated worlds and free from death- or so they think. The book follows a group of polis inhabitants, particularly Yatima, an orphan born inside the Konishi polis. Roughly twenty years after Yatima's birth it is discovered that a local binary star is collapsing inexplicably faster than the known physics should dictate, the eventual collapse of which causes a gamma ray burst destroying much of Earth's surface life. The polises (and Gleisner robots) survive. One such surviving polis embark on a mission to understand what has happened and to prevent something as bad, or worse, happening again. The diaspora occurs when the polis make a thousand clones of itself and many of its citizens, sending them off into the universe to find answers. This book takes you on a vast journey leaving you feeling like you've travelled billions of light years in your own understanding to get where you are. The interactions between humans and the polis citizens is particularly interesting, as well as the clever use of extrapolated physics from the current theories and ideas of our time. Another interesting quirk of the book is that Egan uses gender-neutral pronouns for the polis members who have opted to have a neutral gender. Definitely worth a read!

Diaspora
Greg Egan

Image from Amazon.co.uk

Find this book on:

2 October 2008 15:39:48 - Books | Comments (5)

2008-09-30 - Cambridge etc.

Dominic Orchard — Tue, 30 Sep 2008 11:53:53 +0000

Falling share prices: Even log scale graphs can't make it look good.

Just a quick update of what's going on for me at the moment. I moved to Cambridge last Thursday and have until the 6^th of October before I start in my department so I am just getting settled in, meeting new people, enjoying the city of Cambridge, and doing some occasional reading. I am at Jesus College but live just outside the college in a nice house with a *load* of other grad students. Its near the river, Jesus Green, and Midsummer Common, providing extra motivation to go for morning runs!
We have a really nice library at the college which is providing me with a wealth of maths and science books I want to look at. Maybe I will form some posts around some of the things I am reading if I get time to read and think more.

This week we see Bradford & Bingley's nationalisation confirmed after a spectacular share price descent:

Fortunately PHD comics have calmed any sense of panic for me with their informative and well constructed decision tree... hurray for being a grad student.

30 September 2008 11:53:53 - General | Comments (7)

2008-09-24 - Essay on 3 Emerging Technologies

Dominic Orchard — Tue, 23 Sep 2008 23:19:11 +0000

Essay + domain

I have decided to post an essay I wrote last year that outlines three emerging technologies in the fields of nanohealing, solar energy and neuron control. I really enjoyed researching these topics - which were featured in the 2007 MIT Technology Review of 10 Emerging Technologies - and found each technology, and the underpinning science, very interesting. I decided to post the essay here if anyone is interested. Download the PDF or read it online courtesy of PdfMeNot.com:

In other news I have purchased http://dorchard.co.uk which points here (I have also switched from the riftor subdomain to dorchard subdomain on G615). Apologies to the select few of you who are subscribed to my RSS feed- I changed the addressess in the feed so now all posts will probably appear as unread. Sorry for the inconvenience!
My next post will probably be from Cambridge as I move in 2 days time!

23 September 2008 23:19:11 - Science | Comments (5)

2008-09-19 - Yarr me hearties!

Dominic Orchard — Fri, 19 Sep 2008 11:57:26 +0000

Happy International Talk Like a Pirate Day

Ahoy! Happy International Talk Like a Pirate Day (shouldn't that be hyphenated?). For all those Facebook users, if ye want some midday mirth you can change your Facebook account language to "English (Pirate)".
Examples are: "Home" -> "Home Port", "Friends" -> "Me Hearties", "Messages" -> "Bottle o' Messages", "Search" -> "Scour", "Logout" -> "Abandon Ship", and my favourite "video" -> "possessed portrait"!

This is Cap'n Orchard Abandoning Ship to do something else productive....

p.s. In the spirit of all things Pirate - this is a hilarious Smorgtees t-shirt design of a Pirate Encyclopedia. Arrr!!!

19 September 2008 11:57:26 - General | Comments (4)

2008-09-17 - My trip to Brussels

Dominic Orchard — Wed, 17 Sep 2008 13:10:50 +0000

Photos from my trip to Brussels

Recently I went on a fun trip to Brussels to basically soak in the culture for a few days. It was great fun- my friend and I serendipitously visited during the national beer festival which provided us with large amounts of Belgian specialty beers. Here are a few of the photos from the trip:

www.flickr.com

More of d.orchard's stuff tagged with Brussels

We stayed in a relatively nice hostel in the north of the city, just a short 10 minute walk from the centre. We walked round lots, enjoyed an art gallery, enjoyed the flea market, and of course waffles, chocolate, mussels, and beer.
Here is a video I cut together from some of my footage of the Dexia Tower in Brussels, a tower whose windows are individually illuminated by flourescent tube lights turning the building into a giant pixel array.

17 September 2008 13:10:50 - Travel | Comments (2)

2008-09-15 - Drawing/Colouring Comic Book Style

Dominic Orchard — Mon, 15 Sep 2008 00:00:00 +0000

A time lapse

A time-lapse of me doing a bit of comic book drawing for fun. The drawings and concepts are copied from the Amory Wars comic book series.Video | Comments (4)

2008-07-14 - Degree: over.

Dominic Orchard — Mon, 14 Jul 2008 00:00:00 +0000

So yet again its been an inordinate amount of time since my last blog post; why am I so bad at this? Nevermind. Maybe now that I am on holiday I can update a bit more.

I have now completed my final year at Warwick and will be graduating tomorrow with an MEng in Computer Science with First class honours- assuming I don't get arrested in the next 24 hours and have my degree revoked- not that I think this will happen!
I received my exam results a couple of weeks ago. This year went very well for me and was probably my most consistent year- the standard deviation of my marks per module was lowest this year. I received the award for the "Best overall graduating MEng student in Computer Science for 2008", which I am very pleased about. And now it is all over, culminating in my formal graduation ceremony tomorrow in the Butterworth Hall at the Warwick Arts Center.

I feel extremely fortunate to have gone to such a fine institution and studied in a great department with wonderful people. This last year has been extremely enjoyable- despite also being the most demanding year of my life, with a lot of very late nights and all-nighters. I hope to write about some of the results of the 4th year group project I took part in, which was probably the most enjoyable part of the year for me (academically).
Besides academic enjoyment I treasure everything about my Warwick experience: the friends I've made, the fun we had, growing in my faith as a Christian- in my church and in the Christian Union, parties, making music with friends, dancing, late night chats, early starts, crazy trips to Tescos late at night, shared meals, morning saunas, Monday fried breakfasts. Everything. I've met some of the most wonderful people at university, and for that I am ever thankful!

There is far too much to say about how this year has been for me, so perhaps I will leave some of it for another time. However, I will say that over this last academic year I have begun to dip my toe into the pool of academic research. During the Autumn of 2007 I wrote a paper detailing my work on the integration of object-oriented programming and the dataflow paradigm, specifically my language Lucian, and the notion of intensional objects [more on this later]. The process of writing the paper was extremely valuable. I was able to crystallise my ideas, as well as get a taste of academic writing. My 3rd year supervisor Steve Matthews co-authored the paper- contributing many ideas to the research, spending large amounts of time with me chatting about ideas, scribbling on white boards, and reading through many drafts and revisions. Sara Kalvala was also extremely kind, reading through drafts and giving me advice on writing. The paper went through the first round of reviews and got accepted on the proviso I made some revisions and clarifications. This process was also extremely beneficial. By this point I had learnt a lot more about writing, and had crystallised some ideas even further- and so was able to rework the paper and improve its clarity.
These were all valuable experiences.

Back in February I attended Fun in the Afternoon which I thoroughly enjoyed and which gave me a further view into the Functional programming research community.

During this year there has been an unofficial "language club" in our department, where a group of programming language enthusiasts in the department- staff and students- have been getting together weekly to discuss papers, and give informal presentations. The "language club" was birthed to fill the hole left by the (current) lack of a programming languages research group at Warwick. It is a great idea and has provided a nice forum for chatting about programming language research.

And then finally I spent a lot of time during the second term thinking about PhD proposals, reading a lot of papers, having ideas, and eventually writing a couple of proposals to submit with PhD applications. My applications were successful thus in September I am going to be starting my PhD at Cambridge University, as a member of Jesus College. I am very excited!

I'm glad I stayed at Warwick for another year, not only did I have a lot of fun, and learn a lot, but it provided me with a lot more opportunities to get into the 'research' mindset, and gave me time to get PhD applications and proposals together- which was not an easy process.

Currently I am on holiday till September when I move to Cambridge. Tomorrow is my graduation from Warwick. I will post some photos up soon after I get back from visiting friends around England and my friend's wedding.General | Comments (3)

2008-02-16 - Book recommendation

Dominic Orchard — Sat, 16 Feb 2008 00:00:00 +0000

The Elements Of Style (illustrated)
Strunk, White, Kalman

A great book that plainly and concisely explains the basic principles of English and how to apply them in writing.

Image from Amazon.co.uk

Books | Comments (2)

2007-12-31 - Happy New Year

Dominic Orchard — Mon, 31 Dec 2007 00:00:00 +0000

Just to say I hope everyone had a great Christmas and that they have a Happy New year! :)General | Comments (0)

2007-12-24 - Creating an application with micMVC

Dominic Orchard — Mon, 24 Dec 2007 00:00:00 +0000

The following is a step-by-step guide/tutorial to getting an app going with micMVC. It should be pretty straight forward as micMVC aims to be simple. The sample application outlined in this tutorial can be downloaded here.

Step 1: Download and uncompress micMVC. Download the main micMVC package and uncompress it in your project directory. For this example we will create a names database, so call the directory namesdb.

$> mkdir namesdb
$> cd namesdb
$> wget http://riftor.g615.co.uk/micmvc/micmvc-release.tar.gz
$> tar -zxf micmvc-release.tar.gz

This creates the following directory structure:

app		The app directory contains the main application code
	controllers	Controllers are the basic logic behind your interface, they typical provide the "business logic" link between the interface and database.
	application_controller.php	All controllers inherit from this controller, hence any functions you want to re-use in other controllers should be included here.
	helpers	Helpers provide methods for use in the interface, views
	application_helper.php	All helpers inherit from the application helper, hence this is a useful place to put any methods you want to use in all helpers/views.
	models	Models are objects that "model" a database table. A single instantiation of an model represents a record in the database where the attributes of the object correspond to the fields in the database table.
	views	Views are the interface designs and definitions. These typically contain mostly HTML with some basic PHP for handling data from the controllers.
	error_no_action.php	This page is loaded when an action that doesn't exist is called from a controller. This acts as a 404 error page.
lib		This contains the libraries for micMVC, most of which can be left alone by the user. A description is given here for completeness and developers.
	DBQuery.php	Contains the DBQuery class for accessing the database (MySQL implementation).
	MicMVC.php	The common include for handlers, brings together models is also contained in this file. Edit this file to include configuration for your database.
	Model.php	Contains the base Model class for accessing database tables and facilitating models.
	UnitTest.php	Contains the base Unit test class for unit testing.
script		Contains PHP scripts for running tests and creating/removing controllers, models and views from your application.
	generate.php	Script that generates new controllers, models and views in the application.
	remove.php	Script that removes controllers, models and views from the application.
	run_tests.php	Script that acts as a test suite for running all tests in the application
test		All tests should be placed in this directory.
	unit	All unit tests for models are generated here.

Step 2: Create a database and a table and get micMVC to generate a model. In MySQL create a database called namesdb and a table called person:

mysql> create database namesdb;
Query OK, 1 row affected (0.00 sec)

mysql> use namesdb;
Database changed
mysql> create table person(
    id integer auto_increment,
    firstname varchar(64),
    lastname varchar(64),
    age integer,
    PRIMARY KEY(id)
    );
Query OK, 0 rows affected (0.02 sec)

mysql> GRANT ALL ON namesdb.* TO namesdb_user@127.0.0.1 IDENTIFIED BY 'n4me5db';
Query OK, 0 rows affected (0.05 sec)

Now we need to tell micMVC to generate a model for us called "Person". IMPORTANT The name of the model must be exactly the same as the table name in the database (no pluralization rules). We generate the model by running "script/generate model person" in the top level directory of the application.

$> script/generate model names
        creating new model: names
        creating file...         app/models/person.php
        creating file...         test/unit/person_test.php
        adding test to suit...
        adding model into application...
        done.

We now have a model and a unit test for the model. This model can be removed by running "script/remove model person".
We also added the user "namesdb_user" to the database earlier. We now need to configure the database for access in the file lib/MicMVC.php filling in the configuration part as such:

// 

$host = "127.0.0.1";
$username = "namesdb_user";
$password = "n4me5db";
$database = "namesdb";

//

We are now going to write some tests and some model code to help us out later.

Step 3: Write tests and code for the model. For this example we are going to write a function that compares two records based on the age so that we can sort the records based on age. This is a slightly useless example as we could easily get the database to sort for us, but it demostrates writing and testing custom model functions. We will develop the test first. Open up the newly generated test/unit/person_test.php. We add the method "testCompare()" inside the "PersonTest" class.

		
		function testCompare(){
			// Create a person
			$person1 = new Person();
			$person1->firstname = "Malcolm";
			$person1->lastname = "Reynolds";
			$person1->age = 38;
			
			// Check this saves ok
			$this->assert($person1->save());
			
			// Create another person
			$person2 = new Person();
			$person2->firstname = "Jayne";
			$person2->lastname = "Cobb";
			$person2->age = 36;
			
			// Check person2 saves ok
			$this->assert($person2->save());
			
			// Test the compare function
			// We expect person1 to be greater, therefore return 1
			$this->assert_equal(1, $person1->compare_to($person2));
			
			// And inversely to get -1
			$this->assert_equal(-1, $person2->compare_to($person1));
			
			// If we set the ages the same then we expect a result of 0
			$person2->age = 38;
			$person2->save();
			
			$this->assert_equal(0, $person1->compare_to($person2));
			$this->assert_equal(0, $person2->compare_to($person1));
			
			// Remove the test data
			$person1->destroy();
			$person2->destroy();
		}

This should demonstrate how to use models. A new record can be created by instantiating a model class e.g. $person1 = new Person(); This model can be saved or updated (INSERT or UPDATE) by calling the method "save()" on the object, e.g. $person1->save(); Fields of the record can be set as attributes. A record can be removed by calling "destroy()" on the object e.g. $person1->destroy();.
Assertions can be tested with $this->assert($boolean_expression); and $this->assert_equal($expression1, $expression2); from within any unit test class.
Now we have the test in place, lets write the code! Open up "app/models/person.php" and edit it as such:-

age < $person2->age) {
			
				// This person has a lower age
				return -1;	
				
			} elseif ($this->age > $person2->age) {
			
				// This person has a higher age
				return 1;
				
			} else {
			
				// The ages are equal
				return 0;
				
			}
		}	
	}

?>

Now we have both the model and test for the model, lets run the test suite. Do this by running script/run_tests

$> script/run_tests

PersonTest: running tests
         Running test: testCompare              ......
         Test finished. 6 of 6 assertions passed (100%)

PersonTest: Tests finished. 6 of 6 passed (100%)


All tests completed successfully!
1 out of 1 tests completed successfully.

Step 4 - Create the controller and write the interface - We now write the code for the interface before writing the controller. If we generate a controller an interface template for the controller is also setup for us.

$>  script/generate controller people
        creating new controller: people
        creating file...         app/controllers/people_controller.php
        creating file...         app/helpers/people_helper.php
        creating file...         ./people.php
        creating directory...    app/views/people
        creating file...         app/views/people/index.php
        done.

You'll notice that along with a controller and a helper being generated, we now have a folder named "people" created in the "app/views" folder. This is the location for the interface, "view" code. There is also a file created called "people.php" in the top level directory. This acts as the handler to the people_controller. We will add the following code to the "app/views/people/index.php" view, adding the following code to create a simple form for adding people to the database.


	
		First Name: 
		Last Name: 
		Age: 
	


	
	message) ?>

We will also add some code immediately after this for displaying all the people in the database.

List of People: people) ?> entries

people as $person) { ?>
	
	First name
		Last name
		Age
	

		firstname ?>
		lastname ?>
		age ?>
		Delete

First name	Last name	Age
firstname ?>	lastname ?>	age ?>	Delete

Step 5: Write the controller code: First we add code for handling the index page, adding people to the database, and the delete function.

people = Person::find_all("person");
			$this->render("index");
		}
		
		// Handle adding people to the database
		function add_person(){
		
			// Create a new Person record
			$person = new Person();
			
			// Set the fields
			$person->firstname = $_POST["firstname"];
			$person->lastname = $_POST["lastname"];
			$person->age = $_POST["age"];
			
			// Save the record
			$person->save();
			
			// Set a message for the interface
			$this->message = "{$person->firstname} {$person->lastname} saved.";
			$this->index();
		}
		
		function delete(){
			// Find the person with id $_GET["id"]
			// and delete it
			
			$person = new Person($_GET["id"]);
			$person->destroy();
			
			$this->message = "{$person->firstname} {$person->lastname} deleted.";
			$this->index();
		}
	}
?>

Next we also add the following function inside the controller for performing sorts

	function sort(){
	
		if(!strcmp($_GET["type"], "age")){
			$people = Person::find_all("person");
		
			// Use a bubble sort
			for($i = sizeof($people) - 1; $i >=0; $i--){
				for($j = 0; $j < $i; $j++){
					if($people[$j]->compare_to($people[$j+1]) == 1){
						$tmp = $people[$j];
						$people[$j] = $people[$j+1];
						$people[$j+1] = $tmp;
					}
				}
			}
			
			$this->people = $people;
			
		} elseif (!strcmp($_GET["type"], "firstname")){
			$this->people = Person::find_all("person", "1 ORDER BY firstname");
					
			
		} elseif (!strcmp($_GET["type"], "lastname")){
			$this->people = Person::find_all("person", "1 ORDER BY lastname");

		} else {
		
		}
		
		$this->render("index");
	}

And that's it! We now have a fully working names database where we can add, delete and sort our results. If you point your browser at your application directory at people.php then you can see it in operation (e.g. at http://127.0.0.1/namesdb/people.php). Programming | Comments (4)

2007-12-19 - Christmas holiday so far

Dominic Orchard — Wed, 19 Dec 2007 00:00:00 +0000

Hi all,
Well term has finished and I am now on my Christmas holidays. I recently went to Edinburgh to have some fun with some friends and also had the privelege of meeting up with some great computer scientists at the University of Edinburgh to talk about PhDs which was very interesting. Here are few select snaps from our little holiday:

Besides visiting Edinburgh I also visited Cambridge recently to meet with people at the Computing Lab at the University of Cambridge and Microsoft Research to discuss perhaps doing a PhD next year.
I am now at home and back at my part-time job as a software developer which is going great. I have recently been developing a domain-specific language/algebra for expressing product promotions within my web-order entry system.

For all who are interested I will shortly be uploading a load of work I have been doing over the last year or so on various projects and research, including my language Lucian. If anyone is looking for my work on Lucian (which I know a few people are), then it will be appearing on this site by the weekend.
Thanks!General | Comments (3)

2006-09-05 - Ruby on Rails, XML Deserializer

Dominic Orchard — Tue, 05 Sep 2006 00:00:00 +0000

An extension to ActiveRecord::Base to complement the to_xml method

While working on a project recently using the Ruby on Rails framework, I required full XML serializing and deserializing of my models (database tables) for an information services layer.

I discovered quickly that there exists a "to_xml" method for ActiveRecord instances, but no complimentary method for deserializing an ActiveRecord instance. I Googled around and found an example of such a method the blog of Wayne Robinson, which was a really good start to the problem. Then I set about making it more sound

Please leave feedback & comments as I'm aware that it may need some more fine tuning as I can only test its robustness against my own project.

Thanks to YMMV and another anonymous commentor who fixed a couple of small bugs for has_many associations and uppercase attribute names. Updated 2007


module ActiveRecord
  class Base
  
    # XML Deserializer for ActiveRecord
    # by Wayne Robinson and Dominic Orchard
    def self.from_xml(xml)
      if xml.class == String
          # If passed a string, convert to XML object, and set root
          xml = REXML::Document.new(xml) 
          root = xml.elements[1]
      else
          # If already passed an XML object, then set root to XML object
          root = xml
      end
      
      if  ((root.name.underscore != self.class_name.underscore) and 
             (root.name.underscore != self.class_name.pluralize.underscore))
              # Check the top level is actual refering to the class
              # e.g. , for class Customer
             return nil
      end
      
      # Deal with XML data containing many record instances
	if (root.name.underscore == self.class_name.pluralize.underscore and
	    self.class_name.pluralize.underscore!=self.class_name.underscore) or
	    root.name==root.elements[1].name
        
		root.elements.inject([]) do |instances, element|
			instances.push(self.from_xml(element))
		end

        else
            # Try to retrieve from ID in
            # XML data and update this record or start a new record
            # Find an id element in the elements
            id_element = root.elements.inject(nil) do |found, element|
                  if element.name=="id"
                        element
                  else
                        found
                  end
            end
            # if we haven't found the ID element
            if id_element.nil?
                  new_record = self.new
            else
                  # Retrieve from XML
                  begin            
                      new_record = self.find(id_element.text.to_i)
                  rescue
                      # If that record in fact didn't exist... start a new one
                      new_record = self.new
                  end
            end
            
            # Iterate through elements
            root.elements.each do | element |
                if ele.name.upcase == ele.name
			sym = ele.name.to_sym
		else
			sym = ele.name.underscore.to_sym
		end 
      
                # An association
              if element.has_elements?
  
                setter = (sym.to_s+"=")
                # Check the setter is an instance method
                if self.instance_methods.member?(setter)
                      klass = self.reflect_on_association(sym).klass
                      new_record.__send__(setter.to_sym, klass.from_xml(element))
                end
    
              # An attribute
              else
                  # Check that the attribute is actual part of the record
                  if new_record.attributes.member?(sym.to_s) || sym==:id
                      if element.text.nil?              
                            col = new_record.column_for_attribute(sym)
                            # Handle an empty element with a not null column
                            if !col.null
                                # Use default value
                                new_record[sym] = col.default
                            end
                      else
                            new_record[sym] = element.text
                      end
                  end
             end
          end
  
          new_record
        end
     end
  end
end

Wayne Robinson recommended placing this code into the bottom of your config/environment.rb file for inclusion into your models.

Download source file
Download unit tests

(Code is presented as-is with no guarantees!)Programming | Comments (9)

2007-11-30 - Obligatory late night post

Dominic Orchard — Fri, 30 Nov 2007 00:00:00 +0000

Just to say that its 6:43am and I am finally folding into bed after completing a poster, a portfolio and a paper tonight! It feels good to have three largish pieces of work complete but I hope that I will maintain some kind of lucid thought tomorrow! Good night all!Tired | Comments (4)

2007-11-27 - PhDs, Research, Undergrad work

Dominic Orchard — Tue, 27 Nov 2007 00:00:00 +0000

I am currently heavily in embroiled in completing a paper for submission in the field of intensional programming. This is basically consuming most of my time on top of standard undergrad work.

My typical day consists of stumbling out of bed at 8:45 or 9:45 to get to a meeting/lecture at 9 or 10 respectively. I then spend most of the day in lectures and meetings and working on bits of undergrad work until about 6/7 when I eat, then start up the day of a researcher, working on the research and paper until about 3/4am when I finally get into bed then can't sleep because my mind is racing!

But I'm not complaining about this because, although its hard work, I enjoy the research and I hope that the hard work I have put into the paper will pay off.

At the same time I am also investigating where I would like to do a PhD next year and am tentatively pushing doors at the moment to see where I could go. Fun times!Research | Comments (5)

2007-11-13 - Paul Hammond speaks on Flickr

Dominic Orchard — Tue, 13 Nov 2007 00:00:00 +0000

My department had the good fortune of Paul Hammond from the Flickr team coming to speak to us today about the backend infrastructure of Flickr and how it maintains Scalability, High Availability and Performance through clever server interactions and middleware to ensure a solid (but not perfect) and fast service.

Apologies Paul! A Warwick Uni CS department classroom is not exactly a glamarous venue!

One interesting point that I took away from the talk that I'd like to share now was that, once again, certain methods are simply not practial or are simply unnecessary for certain applications. For instance Flickr's backend will occasionally experience some database inconsistency across shared data, however it is willing to admit this and explain this to the user simply where it is appropriate (a warning about data not being available yet).
The point is that Flickr isn't a safety critical system and certain systems can be made to run very fast for a very large number of users with a very occasional lapse in accuracy that is admitted rather than fixed, affording occasional slip-ups in non-critical data (such as user comments)

Another point that I thought was very interesting was a quote that Paul accredited to his boss; "Normalised data is for sissies." Eloquently put! When designing databases my relational-database-computer-science-sense^TM kicks in and I automatically dive into highly normalised tables resulting in many small tables with many relationships but I've always had this fear that sometimes I've gone too far and comprised on speed.
Denormalisation can be a tricky business, however in practise denormalisation of data can be very useful from an optimisation point of view. For example Flickr, as Paul explained, stores the number of photos uploaded by a user in the user record, instead of counting the photo records belonging to the user each time the count is requested. This saves a lot of processing as the photo count is used frequently. When a new photo is added the photo count is recalculated from the database to prevent some strange race conditions occuring (not too likely in this case unless the user was uploading two photos at once).

Paul Hammond certainly knew his stuff and it was a great talk that I feel helped me to grasp a stronger handle on some ideas that I already had lurking in the back of my mind about how to run scalable applications.

Anyway enough rambling, I am departing tomorrow afternoon to head to Quinta near Wales for a Christian Union weekend away which I'm sure I will immensly enjoy and will get some good timeout and perspective. Thanks.Tech | Comments (8)

2007-11-21 - Bugs, Ruby, Macros

Dominic Orchard — Wed, 21 Nov 2007 00:00:00 +0000

My day in 3 nouns

I have been figuring out some tricky bugs in a fairly sizable and complex Ruby on Rails app I am involved in and found some well hidden but potentially serious bugs that have slipped through the net. This resulted in me writing a correction function that takes almost 4 minutes to run and which actually causes the fastcgi handler to keel over, hence I must run it from the console instead.

Anyway, while googling for a particular Ruby trick I discovered this interesting post dubbed "Python Style Ruby".
This post defines a method for writing Python style code in ruby (with off-side rule indenting and colons). This isn't amazingly useful per se, but the technique employed is very clever. Using Ruby's deeply object-oriented nature this method works by simply require a module at the start of the "pythonized" file which reloads the caller file, processesing it, transforming it and cleanly evaluating the code back in to the module.
I had never seen a method of loading up a caller file from an included module and had never really thought about whether that was possible, but this little method opens up a nice way to include macros without an external pre-processor.

My mind began racing as I started wildly hacking 'defmacro' style constructs into Ruby. A few regular expressions later and I remembered how much easier this kind of activity is in Lisp where blocks of code are so easily handled, examined, reparsed, partially evaluated and manipulated, a task not so easy in Ruby where some internal AST is hidden and likely obfuscated. So how does one get a nice clean system for macros in Ruby? Well, currently as I am going away tomorrow and have a bunch of assignments I should be doing as opposed to implementing a Ruby macro system I am putting this little project on the side, but I will pick it up hopefully shortly and get something posted because quite frankly, macros are delicious.
Programming | Comments (4)

2007-11-21 - URSS Poster Exhibition Ceremony

Dominic Orchard — Wed, 21 Nov 2007 00:00:00 +0000

Earlier this week I presented my poster and research that Daniel James and I carried out over the summer funded by the University of Warwick URSS (Undergraduate Research Scholarship Scheme) at an all day event dubbed as a 'Posted Exhibition Ceremony'. I very much enjoyed talking to people about my work and people seemed very interested (mostly because my research was robotics related (more to come soon on this)). It was also immensely enjoyable talking to other undegraduate researchers, examining their posters and discussing their results. The posters for all of the researchers can be found here, my poster can be found here also. Hopefully some pictures from the event will circulate soon as there was an official photographer, I unfortunately forgot my compact in the mad rush having only a few hours sleep previous. Free lunch and danish pastries were an added bonus.
Poster | Comments (6)

2007-10-28 - Robot Navigation and Control

Dominic Orchard — Sun, 28 Oct 2007 00:00:00 +0000

Poster presentation of research

An A1 poster designed by myself summarizing research carried out by Daniel James and I in the area of robot navigation and control during Summer 2007 (see Research section). This poster was a requirement of the research funding and is being presented in November 2007.
(Click for a larger view).Poster | Comments (3)

2006-01-31 - Shoes, hands and statues

Dominic Orchard — Tue, 31 Jan 2006 00:00:00 +0000

A subset of my work from AS-level Art (2003)

Module 1 : Still life drawings/paintings

Module 2 : Hands

Module 3 : Brazillian/African statues ad abstractum Art | Comments (2)

2006-01-31 - Anomality

Dominic Orchard — Tue, 31 Jan 2006 00:00:00 +0000

A painting/oil pastel/pencil piece

This is a piece of art I created back in 2003 when I was still at school using a mixture of acrylic paints, oil pastels and pencils. Feel free to express your interpretations! Art | Comments (4)

2007-01-13 - Compiling wxHaskell 0.9.4 for wxWidgets 2.8.0

Dominic Orchard — Sat, 13 Jan 2007 00:00:00 +0000

Guide and modified code for the latest versions

For a project I am using wxHaskell for some GUI and graphics things, so I went to install it. But I found that, once downloading the latest source for wxWidgets (December 2006) (2.8.0), that I couldn't compile the latest (May 2005) (0.9.4) due to quite a few compile errors. I had a look online and saw a few other people having the same issue and didn't want to really have to use an older version of wxWidgets from 2 years ago. So I set about trying to write fixes and make some hacks to get wxHaskell working with 2.8. I hope the information and code will be useful.
Note: I am using Suse Linux 10.1 with 2.6.13-15.12 kernel and GHC 6.4.1 (I know I'm a bit behind on GHC)). All the information presented here is AS IS. I haven't fully tested all the features in wxHaskell using this modified source so its not impossible there may be a couple of obscure features that don't fully work as they are supposed to, but the majority I think it will be fine.

Step 1 - Download the latest wxWidget 2.8.0 and compile + install. When you configure you MUST add the argument --enable-compat24.
I did:-
./configure --enable-compat24
make
make install
Step 2 - Download and extract my modified source for wxHaskell 0.9.4. Don't compile and install yet
Step 3 - Set your wxWidget includes to use WXWIN_COMPATIBILITY_2_4 mode. This can be done by finding the setup.h file. I found mine by doing:-

find /* 2>/dev/null | grep wx | grep setup.h

And on my machine it was located at /usr/local/lib/wx/include/gtk2-ansi-release-2.8/wx/setup.h Edit this file and find the line that is:-

#define WXWIN_COMPATIBILITY_2_4 0

Line 155 for me And set it to:-

#define WXWIN_COMPATIBILITY_2_4 1

Hence turning on 2.4 compatibility.
Step 4 - Go back to source for my modified wxHaskell 0.9.4. and do the usual:-

./compile
make
make install

Then you should be good to go. Test the samples to make sure its all good.

Here is a reasonably complete list of the changes I made. A few may be omitted as I was trying to do this as fast as possible for a project, there may be some dirty hacks, some of the code is good though! Please leave feedback if you find that this process is wrong, or have any other queries, or things happen differently with your configuration.

Tech | Comments (6)

2005-11-05 - Natural Primes in SML

Dominic Orchard — Sat, 05 Nov 2005 00:00:00 +0000

Lazy lists and Sieve of Eratosthenes method in SML

Example of lazy lists in SML, using Sieve of Eratosthenes method to produce a lazy list of prime numbers.

Code


structure Lizt = 
	struct
		datatype 'a lizt = empty | cons of 'a * (unit -> 'a lizt)
		
		fun filter f empty = empty
			| filter f (cons(x,xs)) = 
				if (f x) then
					cons(x, fn ()=> filter f (xs()))
				else
					filter f (xs())

		fun hd empty = raise Empty
			| hd (cons(x,xs)) = x
		fun tl empty = raise Empty			
			| tl (cons(x,xs)) = xs()
	end
	
fun naturals n = Lizt.cons(n, fn ()=> naturals(n+1))
	
fun primes(Lizt.cons(x,xs)) = 
		Lizt.cons(x, fn ()=> primes(Lizt.filter (fn y=> y mod x <> 0) (xs ())))
		
	| primes(Lizt.empty) = Lizt.empty

val natPrimes = primes(naturals(2))

Example usage

- Lizt.hd(natPrimes);
> val it = 2 : int
- Lizt.hd(Lizt.tl(natPrimes));
> val it = 3 : int

Programming | Comments (3)

2005-11-08 - Conjunctive Normal Form

Dominic Orchard — Tue, 08 Nov 2005 00:00:00 +0000

A short conversion algorithm in Scheme

This is going to be a brief post of a small program that I wrote in Scheme (a dialect of Lisp). It converts a propositional formula into conjunctive normal form
I hope that this may be useful to someone, it was for me just to get it in my head how the algorithm works, and to check my Logic assignments against ;).

The code should be fairly portable across most Scheme implementations, if not drop me a line.
So without further ado, here is the code:-

(define (cnf x)
  (cnfp (nnf (impl-free x))))

(define (cnfp x)
  (cond ((symbol? x) x)
        ((equal? (fst x) 'and) `(and ,(cnfp (scnd x)) ,(cnfp (thrd x))))
        ((equal? (fst x) 'or) (distr (cnfp (scnd x)) (cnfp (thrd x))))))

(define (distr x y)
  (cond ((equal? (fst x) 'and) `(and ,(distr (scnd x) y) ,(distr (thrd x) y)))
        ((equal? (fst y) 'and) `(and ,(distr x (scnd y)) ,(distr x (thrd y))))
        (#t `(or ,x ,y))))

(define (impl-free x)
  (cond ((symbol? x) x)
        ((equal? (fst x) 'impl) `(or (not ,(impl-free (scnd x))),(impl-free (thrd x))))
        ((equal? (fst x) 'not) `(not ,(impl-free (scnd x))))
        (#t `(,(fst x) ,(impl-free (scnd x)) ,(impl-free (thrd x))))))

(define (nnf x)
  (cond ((symbol? x) x)
        ((and (equal? (fst x) 'not) (equal? (fst (scnd x)) 'not)) (nnf (scnd (scnd x))))
        ((equal? (fst x) 'and) `(and ,(nnf (scnd x)) ,(nnf (thrd x))))
        ((equal? (fst x) 'or) `(or ,(nnf (scnd x)) ,(nnf (thrd x))))
        ((and (equal? (fst x) 'not) (equal? (fst (scnd x)) 'and))
              (nnf `(or (not ,(scnd (scnd x))) (not ,(thrd (scnd x))))))
        ((and (equal? (fst x) 'not) (equal? (fst (scnd x)) 'or))
              (nnf `(and (not ,(scnd (scnd x))) (not ,(thrd (scnd x))))))
        ((equal? (fst x) 'not) `(not ,(nnf (scnd x))))))

(define (fst x)
  (if (symbol? x) x 
      (if (list? (car x))
          (car (car x))
          (car x))))

(define (scnd x)
  (if (list? (car x))
      (cadr (car x))
      (cadr x)))

(define (thrd x)
  (if (list? (car x))
      (car (cddr (car x)))
      (car (cddr x))))

Example usage


> (cnf '(not (impl p (not (and q (impl (not p) q))))))

(and p (and q (or p q)))

> (cnf '(or a (and b c)))

(and (or a b) (or a c))

Notes on code:
The program recognises implication as the symbol 'impl'.
It is split into a bunch of functions, 'impl-free' takes a formula and removes all implications (a -> b), replacing them with "not a" or "b"
'nnf' removes extraneous 'not's and performs deMorgans law.

If you notice a bug, or mistake, or have any suggestions, please tell me. Maths | Comments (1)

2005-10-05 - Displaying continuous data

Dominic Orchard — Wed, 05 Oct 2005 00:00:00 +0000

Anti-aliasing lines and polygon area calculation

Introduction

This article sprang from a problem put forward in "The New Turing Omnibus" by A.K Dewdney, specifically from chapter 29, related to cat-scanning/image processing techniques. The (paraphrased) problem at the end of chapter states, "Given a pixel with unit side, calculate its area of intersection with a band of width w." This sprang forth a lot of thought of implementation, and of other computer applications. Please read on.

Resources
Single square area-calc [Python,PIL]
Single square area-calc, animated [Python]
Multiple squares area-calc, animated [Python]
Anti-aliasing implementation, animated [Python]

This article is in its first revision
October 2005

When an equation of a line is given, say y=x, it can be drawn on paper, as a continuous line, and can be calculated for any real number, with a infinite number of values. When this line is ploted on a computer, the computer display is not continuous, hence the line can only be represented in discrete units (pixels) (see Figure 0).

Figure 0

An interesting problem arises of how to model continuous data onto a discrete display, while maintaining a sense of continuity. This technique is often known as anti-aliasing, and is commonly applied to fonts.
The idea is that some pixels, near extremities, are coloured lighter shades, based on the area of the parent shape that is covering into each pixel (see Figure 1) Some pixels are completely covered by the beam, others are only partially covered, hence have a covered area that can be expressed as a percentage of its total area.
The first challenge is to, given a square area, and equations of two lines, calculate the area of a square that is intersected by 1 or more lines The shape that is produced could be just a triangle (with only 2 intersections and a corner included), or a square (the whole square covered), or some other polygon, with up to 6 vertices (see Figure 2).

Figure 1 - 'Continuous' beam passing through discrete pixels

Figure 2 - Area of different polygons, calculated by splitting into triangles

This area can be calculated by working out the vertices that make up the polygon, and then splitting the polygon into the simplest shapes, triangles, which are easier to calculate the area of. This is shown in Figure 2. These images are generated by a short Python program (using the Python Imaging Library to output the result as a bitmap), [Download areacalc program].

Usage: Python areacalc.py angle beamwidth
e.g.
python areacalc.py 25 100

The program uses a stack to store the points, first checking if corners lie within the beam, and then checking where the intersections are. These points are then sorted (this is important for correctly splitting the polygon into triangles). (see Figure 3 for code). (note 'points' is a stack implementation included in the file, points.a is list used for this stack.)

The next stage of the program is to pop 3 at a time off our stack so that the line lengths and angle between them can be calculated. This can be then used (using some simple trigonometry rules) to calculate the area of the triangle. The middle point is dropped, and the first and last popped points are pushed back onto the stack, hence the shape has been reduced by one point, loosing a triangle on the outside. The process continues until we only have 2 points left, by which time all triangle areas have been calculated. See Figure 4 for the Python code that performs this operation (note. code is included for drawing of the colourful marking triangles). See the note below, labelled "Beam & area equations", for information on the maths used in a non-python format.

Areacalc2 is an animated Tk Python program that shows the different areas that are produced, given an initial angle (in degrees), and a beam width, the program continually scans the beam over the target square, showing the resulting changing areas. [Download areacalc2].
The next step is to perform this operation on multiple squares, or on an area covered by pixels (squares of size 1x1). The Areacalc3 program, when given a square size, generates a list of squares (within a certain range), and performs the operation on all of them. [Download areacalc3]
See Figure 5 for a still image of the program at work.

Usage: python areacalc3.py angle beamwidth squaresize
e.g.
python areacalc3.py 25 100 50

Figure 3 - Vertex detecting and ordering code

# check for corners
for corn in bCorners:
    (yC1,yC2) = calcY(corn[0],beamWidth,theta)
    if(corn[1]>=yC1 and corn[1]<=yC2):
         points.push((corn[0],corn[1]))
         
# check intersections
for calc in [(bStartX,calcY(bStartX,beamWidth,theta)),
            (bEndX,calcY(bEndX,beamWidth,theta))]:
    if(calc[1][0]>=bStartY and calc[1][0]<=bEndY):
        points.push((calc[0],calc[1][0]))
    if(calc[1][1]>=bStartY and calc[1][1]<=bEndY):
        points.push((calc[0],calc[1][1]))
        
for calc in [(bStartY,calcX(bStartY,beamWidth,theta)),
        (bEndY,calcX(bEndY,beamWidth,theta))]:
    if(calc[1][0]>=bStartX and calc[1][0]<=bEndX):
        points.push((calc[1][0],calc[0]))
    if(calc[1][1]>=bStartX and calc[1][1]<=bEndX):
        points.push((calc[1][1],calc[0]))

line1 = []
line2 = []
line3 = []
line4 = []
for point in points.a:
    if(point[1]==bStartY):
        line1.append(point)
    elif(point[1]==bEndY):
        line3.append(point)
    elif(point[0]==bEndX):
        line2.append(point)
    elif(point[0]==bStartX):
        line4.append(point)

line1.sort(lambda x,y: cmp(x[0],y[0]))
line2.sort(lambda x,y: cmp(x[1],y[1]))
line3.sort(lambda y,x: cmp(x[0],y[0]))
line4.sort(lambda y,x: cmp(x[1],y[1]))

points.a = line1+line2+line3+line4

Figure 4 - Triangle area calculation

colour = (0xFF,0x90,0x00)
cx=0
areaTotal = 0
while(len(points.a)>2):
    p1 = points.pop()
    p2 = points.pop()
    p3 = points.pop()

    a = distance(p1,p2)
    b = distance(p1,p3)
    c = distance(p2,p3)
    
    phi = math.asin((a**2 - b**2 + c**2)/(2*a*c))
    
    area = 0.5 * a * c * math.cos(phi)
    areaTotal+=area
    draw.polygon([p1,p2,p3],fill=colour,outline=(0,0,0))
    
    points.push(p3)
    points.push(p1)
    
    colour = (colour[0],colour[1]+16,colour[2])
    cx+=1

Beam & area equations:-

Equations for the y co-ordinates of the beam extremities, given x, the angle of the beam theta, and the beam width b.

Equations for the x co-ordinates of the beam extremities, given y, the angle of the beam theta, and the beam width b.

Area calculation equations given points a, b and c:-

Distance between two points (x1,y1),(x2,y2):-

Figure 5 - Multiple squares being intersected, generated from:-
python areacalc3.py 10 100 50.

Now that we have the area being calculated for any number/size of 'squares' we want, we can now start to reach our original goal, of using this data to display continuous data on our discrete displays, but using shading techniques to make the data appear continuous and 'smooth'.
The program beam.py does exactly this. Instead of drawing the orange triangles the squares are shaded in proportion to the square's intersected area with the beam. In this program there are no outlines around each square so that one can see the effects more prominently if the square size is reduced down to 2x2, or even 1x1 (pixel level) [Note: this is pretty slow, the algorithm is not overly efficient, and a lot of calculations have to be made!]. [Download beam].

The usage is the same as areacalc3 (python beam.py angle beamwidth squaresize). See Figure 6 and 7 for the program in use. As you can clearly see from Figure 6, the squares are being shaded differently at the extremetities (produced by Python beam.py 10 100 10).
Figure 7 shows 1 pixel squares, and the line passing through, creating a nice smooth line.

Figure 6 - Multiple squares being intersected, and shaded accordingly

Figure 7 - Pixel size squares, being intersected, and shaded accordingly

Our goal has been achieved, we can now represent our continuous line in a psuedo-continuous fashion on computer, and in the process we have explored how to calculate the area of a polygon. Note that our method of calculating a polygon's areacalc is not suitable for all polygons, and is not particurlarly efficient. It will in fact only work for shapes that are convex. A convex 2D shade is one in which all inside angles are less than or equal to 180 degrees. However with a concave shape has at least one inside angles that is greater than 180 degrees (see Figure 8).

Figure 8 - Examples of convex and concave shapes

Below is code written in Haskell that presents a more efficient algorithm for calculating the area of convex polygons, and then a more advanced algorithm for calculating the areas of convex and concave polygons.

Figure 9 - Haskell code for calculating the area of only convex polygons, adapted by Daniel James from "The Haskell School of Expression - by Paul Hudak (c. Cambridge Press 2000)"

type Vertex = (Float, Float)
type Polygon = [Vertex]

distBetween :: Vertex -> Vertex -> Float
distBetween (x1,y1) (x2,y2) = sqrt ((x1-x2)^2 + (y1-y2)^2)

triArea :: Vertex -> Vertex -> Vertex -> Float
triArea v1 v2 v3 = let a = distBetween v1 v2;
                       b = distBetween v2 v3;
                       c = distBetween v3 v1;
                       s = 0.5 * (a+b+c);
                    in sqrt (s * (s-a) * (s-b) * (s-c))

area :: Polygon -> Float
area (v1:vs)  = polyArea vs
   where polyArea       :: [Vertex] -> Float;
      polyArea (v2:v3:vs') = (triArea v1 v2 v3) + (polyArea (v3:vs'));
      polyArea _           = 0

Figure 10 - Haskell code for calculating the area of convex and concave polygons, written by Daniel James

trapeziumArea :: Float -> Vertex -> Vertex -> Float
trapeziumArea b (x1,y1) (x2,y2) = 
     0.5 * ((y1-b)+(y2-b)) * abs (x2-x1)

minY    :: [Vertex] -> Float
minY xs = foldl (\\\\z (_,y) -> min z y) 0 xs

isLeft               :: Vertex -> Vertex -> Float
isLeft (x1,_) (x2,_) = if x1>x2 then 1 else -1

isZeroA               :: Vertex -> Vertex -> Bool
isZeroA (x1,_) (x2,_) = x1==x2

polygonArea              :: Polygon -> Float
polygonArea vs = 
    let base = minY vs
    in abs ( polygonArea' base vs )

polygonArea'              :: Float -> Polygon -> Float
polygonArea' _ [v]        = 0
polygonArea' b (v1:v2:vs) = 
    (if isZeroA v1 v2
    then 0
     else ((isLeft v1 v2)*(trapeziumArea b v1 v2)))
     + polygonArea' b (v2:vs)

Sample usage:-

polygonArea [(1.0,1.0),(1.0,2.0),(2.0,2.0),(2.0,1.0)]

(area of 1x1 square).

Note how Figure 9 uses a more efficient means of calculating the area of a triangle, which does not need the calculation of the angle between two sides. The relevant code section is:-

..... let a = distBetween v1 v2;
                       b = distBetween v2 v3;
                       c = distBetween v3 v1;
                       s = 0.5 * (a+b+c);
                    in sqrt (s * (s-a) * (s-b) * (s-c))
.....

Figure 10 employs a method of calculating trapezium areas, instead of triangles. This is (tentatively) a more efficient means of polygon area calculation.
You may want to use these formulas for increased speed of calculation.

If you would like to modify/edit/use any of the code in this article, then please do. There are definately algorithmic improvements that can be made, and there is plenty of work that steams from this, related to anti-aliasing, and polygon manipulation related techniques. The sample applications are good fun to play with, and are reasonably interesting as well.

Please leave any feedback,
Dom. Orchard

Bibliography

Dewdney, A.K. (2001) The (new) Turing Omnibus, W.h. Freeman / Owl Books

Hudak, P (2000) The Haskell School of Expression, Cambridge Press

Acknowledgements

Daniel James for the adapted Haskell code for concave polygons and for convex & concave polygon code.

Programming | Comments (3)

2007-10-21 - Hello World

Dominic Orchard — Sun, 21 Oct 2007 00:00:00 +0000

The first post

Hello all,
This is my new website up and running. I tried to keep the website as simple as possible so that there is not clutter around the content. I hope the design works out fine on all browsers (I have only tested IE and Firefox), please let me know if there are any issues.
Now I have to fill in all the old content! The old website can be found at here
Cheers!General | Comments (4)