Regarding the feeling of resentment at someone hogging the keyboard – well if you feel that way just ask to have a go! This is often not easy if you feel that your partner has more experience of the system, more confidence in knowing what to do, or a greater understanding than you. In this situation you could suggest “ping pong” pairing where you take turns to write a failing test and the other makes it pass.

Some recent advice from a wise colleague who told me the following: first of all that he didn’t care if he never touched the keyboard or mouse as long as he had an input into the design. To point out a missing semi-colon or something else the compiler will pick up is trivial – what is important is to listen, to contribute your own ideas and to come to a shared understanding of the design. So, according to my wise colleague, being the “navigator” is by no means subservient to being the “driver” but is a position of great responsibility. If you don’t understand what your partner is doing, and you don’t have any input into the design, then you are wasting your time and you are wasting the company’s time. “You have got to be strong”, he told me, if the other person is going ahead without you then you must always ask questions, make sure that you come to that shared understanding otherwise there is no point. And being shy is no excuse!

I found all that a bit of an alleluia moment (and sadly I feel I should have realised this ages ago).

It is, of course, easier to pair with someone who has a similar style to yourself. For example, if you like to take time to understand things then to pair with someone quicker and sharper than you can be stressful. On the other hand to pair with some hot shot young coder who is very sharp, has a good memory, and uses different design patterns from the same tired old way you’ve been doing things for years may be a good thing. By taking you out of your comfort zone it could force you to raise your game a bit. That’s another way of looking at it. When faced with this situation you could try making some suggestions to improve code quality and if your partner is genuinely delighted with an idea that improves the code then this is a very good sign. In spite of their scary self possession it shows a commendable lack of ego, a willingness to learn, and a desire just to write good code and get things working in a nice way.

If you do make suggestions and your partner gets defensive and wants to do things their way then why not look at the way you are suggesting things – does it display a lack of tactfulness or skill on your part. Perhaps you haven’t thought the suggestion through enough to be able to explain it properly. Or maybe your partner has a point. Try not to get defensive especially pairing with someone you’re not used to. Remember you’ve got to take time to get to know people.

Regarding shyness and self-consciousness ask yourself could this be a form of “ego” on your part. Most people pairing with you aren’t going to test you or put you under the microscope, they’re more concerned with getting the job done. “People have better things to do than look at you you know” (as my Mum used to tell my younger self when I complained about feeling shy or self conscious).

So far these are the ways I’ve coped with pairing and I’ve got to the stage where I quite enjoy some pairing sessions. Also when I think “I don’t like pairing” I try and ask myself why, and is it me that’s the problem? Often it is.

If the stop instruction is given to the process then:

1. Process lifecycle is set to stopping status
2. No new tasks are allowed to start
3. Tasks already running are allowed to run to completion
4. Last task finishes
5. Process lifecycle is set to stopped status

The threads for an API test would be:

1. Test thread which gives the Process lifecycle the instruction to stop
2. The Process itself which has the lifecycle state (running, stopping, stopped)
3. The task initiator which listens for instructions to initiate tasks and runs them
4. The task threads

How can we test that the correct sequence of events occur when a process is given the instruction to “stop”? For example, to ensure that the a “stop” command doesn’t set the process lifecycle status to “stop” while tasks are still running, or sets the lifecycle status to “stopping” yet still picks up and initiates tasks. Also we need to do things in the test such as wait for tasks to start and then have the test give the “stop” instruction.

The test needs some mechanism to wait for all relevant events to take place then when it’s done waiting it needs some way of checking that the sequence of events happened in the right order, i.e., lifecycle stop happened after tasks had run to completion.

Talking it over with someone in the team he suggested I take inspiration from UI frameworks, e.g., Java Swing and make use of an event listener/notifier pattern whereby listeners in separate threads can be registered to listen out for events of interests and other (notifier) threads can notify their registered listeners of certain events.

I fitted in a listener/notification pattern which meant that I could create a test helper class like this (all code examples in java):

class LatchMonitor implements Listener {
	public static HashMap<String, long> NOTIFICATIONS_LOGGED = new ConcurrentHashMap<String, long>();
	private CountDownLatch myLatch;
	private String myNotification;
	private Long myLatchTimeout;

	public LatchMonitor (String notification, CountDownLatch latch, Long latchTimeout) {
		myLatch = latch;
		myNotification = notification;
		myLatchTimeout = latchTimeout
	}

	public boolean setToWaitOnNotifier() {
		boolean countReachedZero = false;
		try {
			countReachedZero = myLatch.await(myLatchTimeout, TimeUnit.MILLISECONDS);
		} catch (InterrupedException e) {
			LOG.error("Interrupted", e);
		}
		return countReachedZero;
	}

	public void doNotify(Event event) {
		if (myNotification.equals(event.getOccurrence())) {
			synchronized(this) {
				NOTIFICATIONS_LOGGED.put(event.getOccurrence(), event.getTime());
			}
			myLatch.countDown;
		}
	}

 } 

The LatchMonitor uses a CountDownLatch, giving it the capacity to be notified of multiple events, for example, if 3 tasks are running 3 notifications of “task finished” should be received. It uses a HashMap class variable so all instances of LatchMonitor can log their events of interest and the time that they were notified of the event (ConcurrentHashMap is used because of multiple separate threads calling doNotify). Thus if the event sequence matters then NOTIFICATIONS_LOGGED can be used to make assertions as to the sequence of events.

Within the test you can use LatchMonitors to wait and listen for events of interest, in our case, when the lifecycle status has been set “stopping”, when tasks have finished, when the lifecycle status has been set to “stopped”. When these events have occurred the test can continue and go on to make assertions as to timings of these events, i.e., lifecycle stopping time < tasks finished time < lifecycle stopped time.

The LatchMonitor class proved useful however, it did sometimes have the snag of introducing race conditions in the test, for example,

1. Test instructs the process to execute some tasks
2. Test sets a LatchMonitor waiting for task start events
3. Test sends the stop command to the process
4. Tests sets a LatchMonitor waiting for the lifecycle status to be stopping
5. Test sets a LatchMonitor to wait for the tasks to finish and the lifecycle status to be set to stopped

Between 1. and 2. the tasks could already have started before setting the LatchMonitor to wait; so the LatchMontor is waiting for an event that has already occurred. The same thing can happen between 3. and 4, and between 3. and 5.

What I then did was to have the LatchMonitor implement Runnable and set the LatchMonitors running and waiting in separate threads (FutureTasks) right at the beginning of the test. So now the LatchMonitor is given a run method:

public void run() {
	setToWaitOnNotifier();
}

The LatchMonitor is set running and waiting at the beginning of the test before step 1.:

FutureTask<?> futureStart = new FutureTask<Object>((Runnable) taskStartLatchMonitor, null);
Executor executor = Executors.newFixedThreadPool(1);
executor.execute(futureStart);

At step 2. the Test could check:

boolean tasksNotStarted = true;
while (tasksNotStarted) {
	tasksNotStarted = !futureStart.isDone();
}

The test will wait at step 2. for the event, or if the event had already occured the test continues.

This of course makes the test complicated.

Meanwhile, again someone on the team suggested that I take a look at the awaitility package. This is a DSL for testing asynchronous code. Rather than blocking it uses polling to poll for events of interest. I played around with rewriting the tests that I’d done using the LatchMonitor approach to using awaitility. I think awaitility is great and I found it easy to use and thought it made the code less complex, however, it uses polling which could add time to the tests whereas with the LatchMonitor approach the tests block and continue immediately there’s been a notification of the event.

Having looked at the awaitility code I used it as inspiration for a pattern I’ve started to use in both multithreaded unit and api tests. For example here is a Listener:

class TestListener implements Listener {
	private boolean beenNotified false;
	private String myNotification;
		
	public Listener(String notification) {
		myNotification = notification;
	}
		
	public void doNotify(Event event) {
		if (myNotification.equals(event.getOccurrence())) {
			beenNotified = true;
		}
	}
		
	public boolean haveBeenNotified() {
		return beenNotified;
	}
}

1. Set the Listener to listen out for the event of interest
2. Test sets off something which will end up with the event of interest taking place.
3. Test waits :
   

   int waitTime = 0; int waitTimeout = 5000; long pollingTime = 100l;
   while (!listener.haveBeenNotified && !(waitTime > waitTimeout)) {
   	Thread.sleep(pollingTime);
   	waitTime+=pollingTime;
   }
   assertTrue(listener.haveBeenNotified);

4. Test continues with assertions.

This method uses polling rather waiting, but has the advantage of being in the same thread as the test (thus making the test less complex than the LatchMonitor approach). It also has the advantage of not introducing race conditions because if the event of interest has already taken place then the test falls through the while loop straight to the assertion. The waitTimout of course stops the test polling indefinitely if the event never takes place. If you find you have Thread.sleeps in your tests which are causing intermittent failures then I’ve found this pattern helpful in making such tests deterministic (though of course it makes the tests more complicated and verbose).

One book I’ve recently acquired, and which I wish I’d had at the beginning of the project, is Growing Object-Oriented Software Guided by Tests by Steve Freeman and Nat Pryce. I can recommend chapters 26 and 27 for anyone who has to write tests for asynchronous code.

Some common themes, ideas mentioned by more than one speaker were as follows. More than one person mentioned Frigyes Karinthy and the 6 degrees of separation concept. Another theme was the value to researchers of having at their disposal unprecedentedly vast amounts of rich data, the “digital traces” (Kleinberg) of all of our interactions on the web. With this kind of data sociologists and other students of humanity have the ability to examine human behaviour, and may be able to prove and disprove theories by empirical studies at a scale not possible before.  Another common theme was the value of the internet and the web. The value of maintaining the structure of the internet and ensuring its security and scalability and the value of keeping the web democratic and open.

The presentations should be available to view from http://royalsociety.org/Web-science-a-new-frontier/.

When practising the bong lap drill tonight my partner and I slowed it down considerably which I found very useful. Fast drilling of the techniques is rewarding and afterwards you feel as if you’ve had a good work out, but as we’re learning we also need to slow down and think about what we’re doing. My training partner gave the useful analogy of learning to write; when you learn to write as a child you start very slowly but as an adult you can dash off your signature in no time. I suppose Wing Chun is similar to any other manual skill, such as carpentry or bricklaying, in that you need to start slowly but you’ll get faster as you progress to master craftsman stage, i.e., Bruce Lee

These are powerful techniques opened up by having access to huge amounts of data and the writer of the article argues that these techniques will not involve discarding the scientific method but could complement it.

Jon was kind enough to give us a tour backstage before the performance and this was really interesting as we had a go of the camera where the actors were filmed whenever they were projected on to the big screen on stage. We were also shown where the band played in the wings and all the costumes that the actors got changed into as well as some of the settings and scenery (there is a big setting of Tottenham Court Road tube station which appears during the middle of the show). Backstage seemed to me to be a warren of corridors, little stairways and trap doors so goodness knows how the actors remember their way around to rush to the right entrance to the stage.

I don’t often go to musicals and I’d never heard of We Will Rock You even though it’s been going since 2002. It wasn’t what I was expecting, which was a story about Queen, I won’t spoil the story but the surprise element made it all the better. The script was written by Ben Elton and the Queen lyrics were cleverly worked into it, and of course Queen songs lend themselves to that kind of spectacular showing and big stage musical production (both Brian May and Roger Taylor are musical supervisors for the show apparently). For once I bought a programme which was worth the 4 quid as it gave an impressive amount of information and wasn’t just full of adverts. The music is live (of course!) and the band members have played with some high profile rock musicians including Eric Clapton, Meatloaf, Whitesnake and Black Sabbath.

Jon was excellent switching back and forth with ease, as required by the role, from rather gauche and awkward stutterer to confident big stage rock star. He had real charisma and stage presence in what was a very energetic and physically demanding role. The audience were very participative and really getting into it, and of course everyone knew the lyrics and at the end were singing along. There was a great deal of noise and applause at the end of the show along with a well deserved standing ovation.

Afterwards we went to a bar next to the theatre and I popped out to watch with interest as Jon was mobbed by admirers as he emerged from the stage door.

Jon joined us briefly for a drink then headed off home to have dinner and wind down before bed. He was saying that this sort of acting lifestyle is about 5 hours behind the rest of us as of course they’re late to bed and late to rise and do their main work during the evening.

We walked back to our hotel at the end of the evening tired out but happy after a very full day.

It was the Ellen Kent production of Madam Butterfly with the Ukrainian National Opera that we went to see, and we got the £21 mid range tickets and were sat right up in the gods. But this was a good thing as it gave us a great overview of what was going on on stage as well as the fantastic scenery and settings. I’ve seen Madam Butterfly years ago with the opera sung in English, however, this was sung in the original Italian and I was surprised and pleased to see that it was subtitled. I know roughly the story, but it’s good to be able to understand the details of the plot and what the singers are actually on about. Subtitles were displayed right at the top of the stage on a board which looked like the sort of board you see at New St Station to give you the train times. I’ve only been twice to the opera (both times Madam Butterfly), and I don’t know if subtitling a performance like this is the done thing, but I think it’s a splendid idea which should encourage more people like me to come to the opera as they will understand what’s going on, though I can imagine some venues being too snotty to do it.

The previous version of Madam Butterfly that I’ve seen was an excellent production and sung in English (and a good translation as far as I could judge), however, the music and singing in last night’s performance moved me far more. My friend Maria thinks, and I tend to agree, that this is because the opera is meant to be sung in Italian, and when sung in English you’re hearing it in a language that it was not originally designed for, no matter how good the translation is. As the music and language are intertwined perhaps this is why I found the Italian version more engaging.

The role of Madam Butterfly was superbly performed by a young Korean soprano, Elena Dee, in her first professional role. I got the impression reading the review in the Metro that Ellen Kent, whose production it was, doesn’t like overweight opera singers and won’t employ them no matter how good their voices are. However, my friend Maria reckons that opera is one of the performing arts where looks, age and body shape don’t matter; only the voice matters. I tend to disagree when opera is a viewing spectacle and Elena Dee, being young and good looking, really looked the part of Madam Butterfly, played a wonderful tragic heroine and had the most gorgeous voice. The tenor, Andriy Perfilov, playing Lieutenant Pinkerton was excellent and being young, handsome and fit really suited for the role.

I’ve heard several versions of the famous aria at the beginning of the second act, and Elena Dee’s that we heard last night was absolutely gorgeous. However, I’m going to be really picky now and say that Maria and I agreed that her voice tended to lose its power in the lower registers – the best versions of Madam Butterfly that I’ve heard have a warmth and power and vibrancy in the lower notes which to me really packs an emotional punch, but she’s a young singer and certainly has a beautiful voice and I’m sure this will come in time.

There was tremendous applause for her at the end of the show and tremendous applause, as well as some boos and hisses, for Andriy Perfilov in his role as the cad Pinkerton.

The audience were the usual middle aged couples but also a surprising, to me, number of young people dressed up for the evening (well young women to be exact as I don’t think Madam Butterfly would normally attract groups of young men on a night out).

I’ve never been to the Alexandra Theatre before and the seats we were sat in were quite good as they were at the corner of the grand circle – not right at the top, but with a wall behind us so that we could lean forward without annoying anyone behind.

It was a wonderful evening and I’ll certainly go and see another Ellen Kent production if I get the chance.

I’ve seen Swan Lake but this was a modern piece and incorporated more acrobatic movements. All the dancers, male and female, looked very muscular and there was an interesting mixture of body types and heights (unlike the few classical ballets I’ve seen the dancers varied in height from quite short to very tall). It was impressive to see the skill and athleticism of some of the moves. At a couple of points, when the male dancers were on stage, one of them looked as if he were doing a pirouette, but horizontally in the air! (Apparently this is the barrel move and it’s certainly impressive to watch simply for the skill and sheer physical courage that it must involve). All the dancers seemed to have superb control where every gesture from posture to fingertips seemed to have meaning.

The music was quite mournful and was played live by a group of four musicians (grand piano, cello and two violins). There was good use of lighting (rather cold lighting) which seemed to catch the movements of the dancers very well (at first I thought the dancers had finger extensions as their swan like gestures were so graceful, but I think that this was the light emphasising the hand movements).

The piece was long – it started at 7.30 pm and continued until 9.15 pm with no interval and yet I didn’t get bored or restless.

I felt that the audience was unusual for a ballet in that it consisted of a good mixture of ages; along with well heeled retired people who, I imagine, have the time and money to attend ballets, there were people our age as well as a lot of youngsters cheering and whistling loudly at the end which made me feel I must be attending something cool

Belly dancing has an emphasis on isolation of the muscles so that they move while the rest of the body is kept still, for example, in some moves you endeavour to keep the torso, neck and head still while the legs and the side abdominal muscles (the obliques I think these are called) do the work. This concept of isolating certain muscles seems similar to what is practiced in hip hop though of course the dances are very different.

One thing I have noticed is that belly dancing seems to bring out the exhibitionist in some people. At the end of Yasmine’s performance she started to invite people to dance with her and, while being flattered at the invitation, most of us will still let her take centre stage as even with a few lessons we know we’re going to look really rubbish beside her. However, a few people seemed to take this as an invitation to take over the stage, try to push Yasmine out of the limelight and make themselves the centre of attention. Yasmine, of course, handled the matter with grace and inclusiveness, showing tolerance and friendliness to the people concerned who were … shameless, is the word that springs to mind. This is not a judgment, merely an observation, and it can be very funny in a cringe making kind of way.