Isolation

To date, compilers, editors and code management have all been seen as separate. This places bounds on improvements because parts taken and improved in isolation either aren't effective or have a detrimental effect on the system as a whole.

Storage

Almost all programming languages and editors read and write plain text files. This means that what the engineer edits, what the compiler sees and what is stored on disk are forced to be the same at all times. This has the following effects:

1. it prohibits real out of band information, eg comments and inline documentation.
2. storage can't be optimised for anything other than editing, eg use of a tree structure to aid language agnostic comparison tools.
3. style can't be separated from content - where do you like to put your curly brackets? The compiler doesn't care so it should be an editor thing.

Code blocks

Code blocks are currently special in popular languages. This can be evidenced by trying to replicate if within the language using code blocks. For example, in Java, one would have to use multiple classes adhering to an interface or reflection to get the same thing. This is a problem when you're passing code blocks to other parts of the system to be run.

Chopping it all up

The code you write is rarely an island. Your product is not your code; your product is the sum of your code and many other components you didn't write. The management of your code within the context of the multitude of components making up your product is critical. This includes taking account of dependancies across versions and multiple versions of the same component within a system.

Forced optmisation

Here are two examples of creating a mutable hash table:

• Map options = new HashMap(); (in Java)
• NSMutableDictionary options = [NSMutableDictionary dictionary]; (using Cocoa)

Functionally, they're are almost identical. However they are slightly different in that in the the Java example the engineer chooses the performance, and in the Cocoa example, the engineer leaves that up to the underlying API.

Neither is strictly wrong, but neither is quite right either. Java should not force the engineer into premature optimisation, but it's difficult to see how Cocoa can always get it right at run time. There are many examples of this kind of thing in most major languages, especially in the type system.

Solutions?

I suspect that a full versioned bundle that exists both on disk and within the version control system as an atomic object would be a good start. This would contain both source code and compiler output, along with dependancies and version preferences.

As for what the language itself would be like, I think it should at least:

1. natively support multi-threading and the throwing around of code blocks.
2. not contain anything the compiler can work out for itself. Anything not critical to program flow should be in a side channel.
3. not present false dilemmas with regards to optimisation. This could be by allowing the engineer to state a preference in a side channel, or performance metrics from test systems to update the preference for specific platforms.
4. put anything the compiler doesn't need but the engineer would like in a side channel (eg comments) or in editor preferences (eg style information).

• The quick brown fox jumps over the lazy dog.

• The quick brown fox jumps over the lazy dog.

• The quick brown fox jumps over the lazy dog.

All quite different. The final line shows the current Wikipedia style: a compromise between the extremes of the first two. It's pretty much the same for every other web page out there: a compromise between readability of the textual content verses the findability of the hyperlinks.

I propose that this is a false dilemma; possibly coming from an implicit belief that the page is static when viewing lots of text.

I think there are three states a user (and thus the page) should be in:

1. Reading content, not interested in links at all.
2. Looking for links.
3. Checking the link is the right one.

Each transition between the user's state should be accompanied by a change in visuals. For example, the text below decorates links with underlines when the mouse hovers over the link (states 2 ↔ 3).

• The quick brown fox jumps over the lazy dog.

In addition, all the other links on this website should also change visuals between states 1 ↔ 2. If the user moves, the links appear. If the user stays still for three seconds, the links fade away. Interestingly, even though the fade is fast, the visuals just look wrong if it's not there.

For reference, I've implemented the 1 ↔ 2 state change as a small javascipt files called links.js.

However, I'm still not quite content with the results of the 2009 calendar. Specifically, I don't like the month names down the left side as one has to constantly reference the left side of the page even when looking at a date on the right. This is even worse than the similar problem of week day names as the calendar is wider than it is tall meaning the text is even farther from where it is needed.

After many iterations and suggestions from friends I've come up with what I think is a reasonable solution. Each Monday box has an additional value - a three letter month value:

This solution means that month names are never more than three squares away but do not interrupt the user too much by being on every square.

So, here's the first version of the 2010 calendar.

I'm grateful to all the comments I've received. In response, I've made a few improvements:

• The lines between the days have been thinned from 1mm to 0.4mm.
• The colours were originally based off the spectrum. In order to remove any confusion, they have been reversed.
• The month names have been reduced from 15pt to 10pt.

Without further ado, here's the first version of the 2009 calendar.

Ingredients

175g butter
1/4 tsp salt (if butter unsalted)
160g light brown sugar
130g caster sugar
1 large egg
1 tsp vanilla extract
3/4 tsp baking soda (known to work without)
3/4 tsp baking powder
160g plain flour

170g rolled oats
200g raisins

Method

1. Using one bowl, add everything up to and including the plain flour.
2. Mix the contents together.
3. Add the oats and the raisins
4. Mix the contents together.
5. Drop dough on to an ungreased baking sheet with a 5cm gap between blobs.
6. Bake at 190°C for 10 minutes (in a fan assisted oven)
7. Leave to cool

There's no variable for population, so my yearly average of 5.2 thousand Watts in 2003 would give me a measly score of −.23. However, I think my score should be the same as my civilization, which is Type 0.71.

So, I've re-formed the formula to factor in population while giving me approximately the same answer:

All very good. Now imagine that I'm part of Type I civilization, what would my yearly average be? The answer comes to a staggering 4 million Watts. Just for me. A question for a science fiction author might be "What does a civilization look like if everyone has access to a few MegaWatts?"

So, on average, the UK worker is paid £14.40 per hour (before tax). What's interesting about this is that the calculation can be done the other way:

To put this in more personal terms, approximately 4.1 minutes of your life is worth £1. You'll never see that four minutes again; you'll never get it back.

This problem can be mitigated by using a tool called Caffeine from Lighthead Software. Except I forget to switch it off and the machine stay active all night.

So, I've written my own Mac OS X site-specific browser for iPlayer and named it Curtains. When this application opens it goes straight to the iPlayer. When you're on an episode page, the screen will not dim.

So, if this meets your use case too, feel free to download and give it a go:

Curtains

Additionally, there is a project page.

I'd hoped for a book that would tell me what to do. I did get a little instruction, but this was in-between a gorgeous tour of both good and bad practice. It seems clear that the learning is in the doing.

Conveniently, I've just such a project in mind: my calendar. On my cubicle wall is a year planner. It's an A3 photocopy of a an A4 original and a bad photocopy at that.

So, I've tried to improve it, and the result is my 2008 calendar. Here a list of what I've changed:

• The new one is in colour.
• The new one has coloured workdays and white holidays. This makes Wednesday easier to find.
• White borders around the days. The days should be prominent, not the borders.
• Smaller text for the month names to enable bigger day boxes.
• Smaller text for the calendar title. If one doesn't know what year it is by the end of January then a calendar won't be much help anyway.
• Rows are split into three month quarters to make month recognition easier.

I appreciate 2008 is half gone, but this is just a practice. I may improve it for 2009.

Inevitably one does need new features, a programmer cannot live by Strings alone. So lets create a version 2 of Flores, one with more features. The problem with that is that there will be some inevitable questions:

• Will version 1 code work with a version 2 scripting engine?
• Do I have to upgrade to get keep getting bug fixes?

These are valid questions, but they shouldn't even need to be asked. There's nothing wrong with Flores, it's complete in its own right. That's what fulfilling the requirements means. Really what we mean here is: build a new (and different) language on top of the Flores source code and add fundamentally new features.

So, without further ado, meet Georgia. It has the following features:

1. Everything Flores had at release 6 (unless otherwise stated)
2. Natively works with Objects instead of Strings
3. Allowes integers to be parsed without quotes. Eg 1 instead of "1"
4. Digits are not allowed as part of function names.

Georgia is available here and as with Flores I hope you find it useful.

	Unmarried	Church marriage	Civil marriage	Civil partnership
Allowed to use the title marriage
Allowed to use religious wording during ceremony
Valid within religion
Full partnership rights under law
Next of kin
Right to be at partner's hospital bedside
Annulled if not children produced
Allowed joint adoption
Allowable combinations

I hope that clears things up.

It is true we married, each of us, for very different reasons. I remember at the time you may have felt you had no other choice, and I was not a chivalrous suitor. I know you haven't let those early hurts go; I'm sorry that I've never been able to make it up to you.

There comes a time in a country's life, whether they're ready for it or not, when they can't force their partners to stay. I fear my time has come, when I realise that all those thoughtless little things I did will be held against me. I know that you've been drawing away from me a while now and you may think I just don't care any more. Nothing however could be further from the truth: you're more beautiful today than you ever were. And it has been with a heavy heart that I'm getting ready to let you go.

Please know that whatever you may hear, I do want you to stay. Not anymore to have dominion over you, I know that time has passed, but because I like your company, the way you laugh, and all those other little quirks only an old couple can know about each other.

Yours, always

England

After a little thought it was clear that a crime can be split into three sections:

1. Intent
2. Action
3. Outcome

For example, because the driver is concentrating on something else (intent), a car might be wobbling down the road (action) and hits someone (outcome).

What's interesting here is that the criminal justice system, ostensibly in the UK, works the other way:

1. Detect outcome
2. Detect action
3. Ascertain intent

This is necessary because until we see an outcome from the crime, even if that's just someone witnessing it, a crime cannot be judged to have occurred.

To understand the impact of of all of this it may be worth looking at taking the perspectives of the 3 groups in In search of no crime. Here's a table showing what part each group plays in the 6 events from above:

How these different perspectives affect things is left to the reader.

1. a winner
2. a loser
3. an end

A critical point seems to be that until the end of the game there is neither a winner or loser. For example, it makes sense to say "who won the 1997 boat race?"; yet it makes no sense yet to ask "who won the 2097 boat race?".

Now, imagine a game with the following characteristics:

1. it only ends when the last player leaves
2. players can play individually and in any number of teams at the same time, and can change teams at any point
3. players time in the game is finite
4. players can be actively removed from the game
5. most teams take the removal of a member very seriously
6. a losing team always gets another move, even if a proxy carries it out.

It's very difficult to see how one could ever win such a game, or in fact what winning would even mean in such a context.

Now, lets take a specific example of a specific game that most people would characterise with the fist list: a World War I. It seams to fit, there was a winner, a loser, and an end (11 November 1918). Except it didn't, the loser's kept on living and got another move: World War II. All real life conflicts like war, terrorism, gang warfare, or a dispute with your neighbour, are actually of the second type of game, not the first.

Which is unfortunate really; just when the winner basks in glory the loser makes another move. Pity the winner.

Flores has the following features:

1. One data type - String. Well, two if you count the singleton null.
2. The while operator, complete with continue and break.
3. The if operator, complete with else.
4. The = operator.
5. All functions are defined externally in Java as static methods. These have to be added to a Flores engine object at Java runtime.
6. No functions by default. The developer needs to add them.

This may look like an odd features list, but there is method in the madness. I have often needed a small scripting lanaguage with one or more of the following features:

• Security. I want total control over a script's access to the outside world. With Flores, if I don't explicitly add a function, it's not there.
• Maintainability. At 731 lines, including comments, there can only be so many bugs.
• Simplicity. I don't want tail recursion or co-routines. When I say simple, I really mean it.
• Licensing. I need a license that's business friendly, and for that, I've always found the zlib/libpng License reliable.

Flores is available here. If you have some of the same criteria that I do, hopefully you'll find it useful.

However, let's consider the following situation: Alex normally pays £10,000 in tax per year. However, upon reading the Inland Revenue rules, notices that only £6,000 need be paid. What should Alex do? Remember, while a payment may be morally questionable, both are entirely legal.

Clearly, the difference can't be described as tax because Alex isn't compelled to pay it. Therefore, Alex would be making a £4,000 donation to the state.

Isn't Alex nice.

On the surface this is a great idea, but it's important to remember that a choice is only truly free if one's choice isn't affected by another's.

Say Alex and Chris are given the choice of 3 holidays: Norway, Kenya and New Zealand. But if there is only one vacancy per destination Alex and Chris can't both choose Kenya. Not really a free choice.

In order to have a free choice there needs to be at least as many of each option available as there are choosers.

So, imagine we have 450 children and 3 schools. In order to be completely free choice each school needs to make avaliable 450 places: 1350 places in total. However, there are only 450 children, so 900 places will be wasted. This may cost nothing if it takes a school less than 6 months to create a place. If however it takes longer, an actual place, with classes, buildings and the land to put them on need to be built in anticipation of a child coming; but with only a 1 in 3 chance of a child actually coming.

It is clear therefor that, while it is possible to attain this level of choice, it's quite expensive. Oh, and it was your money.

And the moral for this little story? When someone offers you a choice, find out who's paying for it before accepting.

It is clear, if a zero crime rate is to be achieved, that when a crime is committed each member of the society needs:

1. to be persuaded not to commit the crime in future
2. a mechanism by which they may put the event in the past and move on

However, each member cannot be treated in that same way. For instance, the perpetrator should probably be treated differently to the victim. With this in mind, I've split the society into 3 groups:

• The victims
• The perpetrators
• The onlookers (everybody else)

We thus have 6 factors that need to be accounted for in any proposed solution. A solution that takes account of all 6 satisfactorily has, for now, been left as an exercise for the reader.

The current campaign in the UK tells us that in an incident at 30 mph 80% of pedestrians survive. That may sound pretty good until one calculates that the survival rate for Russian roulette is greater than 83% (5/6). I say greater because not all players die, even if shot in the head.

As with all dangerous activities, there is also a risk of serious injury. Being hit at 20 mph is no picnic, but pull the trigger with an empty chamber and you're not going to feel a thing.

In fact, on the whole, making every possible effort not to hit people, in any way, is probably the best policy. It is interesting, though, that the scenario seen as a reasonable compromise really isn't. At all.

In order to make comparisons easy I have decided to split physical networks (as opposed to data) into a stack:

1. Pathway layer
2. Link layer
3. Vehicle layer
4. Object layer

By way of example I have created this table of a few choice networks:

From this a few interesting questions arise. For each network:

1. who controls each of the layers,
2. by how much,
3. and how does that control affect other users?

I'll admit that I haven't thought about those yet, but hopefully this exercise has brought me closer to answering my original question. I'm just not quite sure how.

• Only one marker could be placed
• Descriptions were very limited. For example, one could not add any styling or links

This has now changed with the addition to Google Maps of something called KML which was previously only available on Google Earth. It appears that KML allows one to mark multiple points by:

1. Creating an XML file containing all the points one wishes to describe,
2. Making that file accessible to Google Maps

In order to show this in action I have created the file oaklands.kml. The following things should be noted:

1. The <Point> tag is set out in the following way: longitude,latitude,altitude. This is different to points entered into Google Maps query box which are in the format: latitude,longitude.
2. 
   tags should not be written with any slashes in.
3. All the <description> tags I've seen have their data contained within <![CDATA[ … ]]>. I suggest you do the same.

Now, all that remains is for me to present an updated Google Maps link for Oaklands Community School.

I've never quite been comfortable with the way the rape as a crime is set up. After a good discussion with Miss John, my perspective stems from imagining the following scenarios.

Imagine the situation given that all of the following are true:

1. Alex wishes to have sex with Chris
2. Alex and Chris have sex
3. By some magical mechanism, we can clearly see what is going on inside Alex's and Chris' head

Given these, I can see 4 outcomes:

A

This is a disturbing situation. However, even though we can detect Alex's thoughts Chris can't. Also, Chris is not materially hurt by this.

B

Two people having consentual sex (and hopefully a good time)

C

This is clearly rape. Alex believes that constent has not been given but continues to the detriment of Chris.

D

Alex essentially has a catastrophic misunderstanding of Chris's wishes. This is not a deliberate misunderstanding, we would be able to detect that. However, while this might be seriously negligent, I would be very uncomfortable convicting Alex of rape. I would suggest some extensive education for both Alex and Chris to make sure that in future, they both read and give out the correct signals.

My problem here is that the above analysis raises more questions than answers:

• What qualifies as consent? Can consent be withdrawn, and if so, at what point?
• The definition of rape states that because Chris did not consent, Alex was guilty of rape even in case D. Really?
• Because we can't in fact read peoples minds, how as jurors do we work out who consented, and to what?

It turns out mine are:

• Focus
• Competition
• Strategic
• Learner
• Relator

For me it's a journey in a car that just flows by. I don't have to stop at roundabouts; rather, as I approach junctions, a space appears just in the right place at the right time for me to fit in. As I come down the slip road, drivers courteously move into the next lane to let me in, just as others do the same for them. And at the end of my journey, there's a parking space; not too small, nor too large, but just right for my vehicle to fit squarely in the middle. In short, a set of almost perfect moments.

For me though, perfection requires more. It's a journey, where not only do all those things happen, but I make them happen for all the road users around me.

But here's the rub: better than what? In what way, and why? Well, here is the set of criteria on which I am basing my language:

1. it will be written by me
2. it will be interpreted
3. the scripts in the language will be readable
4. the source that implements the language will be readable
5. the implementation will be in C
6. and none of that fancy C either
7. the source will, if possible, total less than 1000 lines

To answer my questions, for me, the closer a language comes to meeting the needs laid out in one's set of criteria, the better it is. If your favorite language, or maybe the one you've just written, doesn't match the above set (ignoring #1), that's not a problem. You just need to make sure it matches your own criteria.

The point to note about the above list is that I came up with it before I started designing and writing the language. I've stuck to it too, otherwise by my argument, the language wouldn't do what I wanted and would therefore be pretty useless.

I'm still writing my language; I don't feel I want to show it to the world before at least the core is complete. What I will say is that at home I've been working on little else since a few days before Christmas. However, the experience has already been fruitful in that at least one lesson has become very clear: do not design and write a programming language.

I'll admit right now that I don't always get up at 7am. It usually happens for one of three reasons:

• I was up too late the night before
• I made the mistake of pressing the snooze button
• I'm not allowed

It's definitely been an education and I'm happy to say that I've learned a few things:

1. Really, the worst thing that can happen when you wake up is to press the snooze button. Just don't do it.
2. If you go to bed too late then you can safely set your alarm a little later than normal. As long it doesn't become a regular thing.
3. Make sure you come to some kind of concensus with those who share your life. Otherwise, you may be asleep when they want you to be awake.

As a result of this exercise I now class myself as an earlier riser. That's nice, but I think the critical lesson for me has been self control. I now worry less about going to bed late because I know that I can get up when the time comes. That's very liberating.

So, for me it was well worth it. My biggest piece of advice to any potential early risers would be: Take a pair of pliers to your alarm clock and rip the snooze button off.

Henry Scott Holland

1. Find a brick or concrete (your choice) wall
2. Stand 30 metres away from the wall
3. Sprint towards the wall as fast as you can
4. Do not stop or slow down until you have hit the wall
5. Tell me that speed limits are the only requirement for road safety

If my calculations are correct you just hit that wall at around 20 miles/hour (9 metres/second). Now if you managed all the points (including 5) then I'm frankly astonished. Just to see how true you are to your beliefs I'd like you to perform one more test:

1. Stand still
2. Be hit by a wall going 20 miles/hour. It's hard to find a moving wall so try using a family car in place of the wall.
3. Again. Tell me that speed limits are the only requirement for road safety.

Still, I suppose it's better than being hit at 30 miles/hour. However, I think you'd agree that it would be stupid to hit or be hit by a wall in the first place; and that's exactly my point.

Most people would agree that speed limits should not be the only method of road safety, but when we look around the world at what goverments and pressure groups do to directly affect drivers' behaviour it basically boils down to "Drive slower".

I expect and demand better. So should you, of yourself and of others.

I suggest we start at the beginning and remind ourselves of what the axioms for driving should be:

1. Do not hit other road users (pedestrians are road users too)
2. Do not, through your actions, cause any road user to hit any other road user

Now all we have to do is follow them.

Google maps style dragging seems to work with any tool that has the following properties:

• It would take up far more than one page
• Chopping it up into lots of pages makes life difficult

After some thought, I realised that it doesn't matter what the tool is, the mechanism is the same:

1. Create a window on to the larger tiled space
2. Move that window around the space in response to dragging
3. If the space is too large to hold in memory then seamlessly add and remove tiles as needed

The first one to my mind was the calendar, which I decided to build. Before talking about the issues I had building a drag-able calendar, here is the demo.

Right, I trust you've had a good play. I'm not going to tell you exactly how I did it here because frankly you can look at the source code. What I will describe here are the few major problems I had to deal with:

• Only having a passing knowledge of JavaScript

This is my way of saying I'm sorry the code isn't perfect. I didn't create an event model for the calendaring system like Google maps has, mainly because I don't really understand fully how the built in ones work.

• Expansion or contraction of tiles

This was a major headache. When you create an entry the current row expands (try it if you haven't already) and overlaps with the one below. I couldn't work out which one had moved until I realised that only the bottom edge moves. So if two rows overlap, it was the top one that changed and we need to move the bottom one down. Easy.

• The built in Date object

As you may have noticed from the demo, the range of dates is huge. The built in Date object doesn't seem to be able to cope with this and still give accurate days of the week. Also, if one tries to add or remove an arbitrary number of days, weeks or months, the result is a complete mess.

Thus I wrote my own, called DateTime. The code in quite a few major places is directly copied from the SQLite date code. The interface has been written differently because I wanted an almost drop in object to replace my Date code. I'd just like to say that I think the ideas behind the date modification code (DataTime.modify()) are inspired: just being able to change the date so easily is brilliant.

I did start work on storing the entries (you've probably noticed they vanish on reload or zooming) but it was taking forever. It's fair to say that I'm not really one of the world's completer-finishers: I'm interested in fleshing out new ideas, but only to the point where I know they work. So, there you are: A JavaScript Calendar.

For instance, SO16 8BY is the postcode for Oaklands Community School. The marker it places on the map for you is at the wrong end of the street which is very annoying. It turns out that it's possible to take the latitude and longitude from a google url and pop it directly into the query box. Thus the actual location if Oaklands School, 50.942002, -1.453006, can be shown.

The best way to obtain the lat/long of a point is to take a blank map, center the map at the desired point (say by double clicking at that point) and click on "Link to this page". The lat/long value you want is the bit in the url after &ll= and before the next &.

As an extra bonus, Google Maps allows one to add more or less arbitrary plain text into the marker overlay, by placing it in brackets after the query in the search box. So the final map would be: Oaklands Community School.

Unfortunately, this has caused a few problems with my friends. When I get excited about things I talk about them, unceasingly. My friends are truly wonderful people, but there's only so much anyone can take. Not good.

So what follows is an explanation of what I thought Mr Kiyosaki was talking about. I bought a flat last year for approximately £100,000. I could afford this place because although the mortgage (plus a few other costs) was about £250 per month more than my previous rent, I had more than that left over every month. All very nice, but would you spend £100,000 based on just that logic?

Of course you wouldn't. You'd:

1. take inflation into account to count against house value appreciation and payment depreciation over the full 25 years of the mortgage
2. take into account the various costs and limitations you will incur by signing up to a 25 year contract
3. work out the total cost of renting, taking into account savings and investments gained (say with the £250 left over every month)
4. make sure you have a financial plan for the next 25 years before you sign those years away to the bank
5. do lots of other things I can't even think of because I do not have sufficient financial education

I know you would, because failure to do those things and more before spending a total of £200,000 (with interest most people pay double the buying price to the bank) over 25 years would be insane.

The point that I took away from the book is that I do not have sufficient financial education to make competent decisions about my life. I cannot blame anyone else, it is my fault. Further more, now that I recognise this, it would be incompetent of me to continue to abdicate from my financial responsibility to both myself and loved ones.

So, starting last Tuesday morning I began following the Steve Pavlina path to early rising. My normal pattern is to sleep from 1am to 9am. My plan was to get up at 7am and go to sleep when I was tired. Eight days later and I've learned quite a lot:

1. I still sleep about 8 hours a day, I now go to sleep at 11pm. This is annoying as the whole point of this exercise as to give me more time.
2. The first week has been hard. Really hard.
3. Breakfast usually gets me through the first 3 hours of my day until lunch time. My day now starts 2 hours earlier so I'm famished by 10. I now have a stash of apples to keep me going. Five-a-day here we come!
4. My daily routine is now out of sync with Mrs John. She is understandably not happy with being woken up 2 hours early or losing 2 hours with me in the evening.
5. I never knew that there was an actual Saturday morning.

Has it been worth it? Even though I've not gained any time by doing this, being able to get up earlier than 9am is a definite skill even if I don't use it often. Also, gaining half a day I never knew existed has been quite nice.

Will I carry on with the minimum of a month that Steve suggests?

One day at a time.

• Political power
• Good job
• Relationship with one's children
• Relationship with one's co-workers
• Access to one's children
• Pension

Now imagine 2 groups: one has a greater relationship with their co-workers and one with a greater relationship with their children. The first group has more access to political power, the second more access to their children. Which group would you rather be in?

I think neither group is totally happy with their lot. It does, however, do well to remember what each group is missing and how sad that is.