Composer has been making waves in the PHP open source world because it makes it easier for developers to share and reuse code. Developers can declare dependencies in a JSON file then run Composer on the command line to download all the necessary files.

Here at Outlandish Ideas we’re big fans of WordPress as an easy to use and extensible CMS. We’ve recently started using Composer to manage our more complex web projects. And now we’re creating the tools to use both together.

Composer natively supports WordPress plugins using installers however most WordPress plugins do not include a composer.json file which means they cannot be referenced directly. The WordPress Packagist site addresses this problem by scanning the WordPress plugin Subversion repository and generating the necessary JSON files for each plugin. Using it is a matter of adding a couple of lines to your composer.json then referencing plugins as you would any other dependency.
We’ve been very pleased to see the positive reaction this project has received from both the Composer and WordPress communities. It’s still early days so if you experience any problems or have suggestions for improvement, please create an issue on GitHub. Or even better, dive in to the code and fix it yourself!

I attended the first session of the course yesterday which largely consisted of a getting-to-know you orientations session. Each participant had to bring three objects that represented their business – something about where the business came from, something about what your family and friends think about you being an entrepreneur and something about where you want to be.

I brought a frying pan as my first object (it all started when we used to cook each other lunch and work around our kitchen tables), my second was a hammer and sickle T-shirt which I brought out Superman-style (my family and friends are worried I’m selling out) and my final object was a John Lewis bag (John Lewis is one of the UKs largest partnerships and have a great reputation for quality and customer service).

The most popular items were awards, globes and compasses. One of the first participants to present was a little mean and kicked off by saying “I was going to bring a globe or a compass, but then I thought that was lame and clichéd”. Some of the more unusual objects included a hippo tusk (from a game-keeper turned plumber), the shoe from the presenters foot (sandwiched between a very funky pair of Jimmy Choo shoes) and the hammer and sickle T-shirt.

It was a great day and the staff from UCL and Goldman Sachs were really good fun. It was amazing to see what a diverse range of people ended up in the room — people who run social enterprises, aspiring Bransons who want to take over the world and people who are just muddling through. There were people from animatronics companies, people who manufacture clothes and people who sell doors door-to-door. Some people had been in business for years, some had just started. I’m really looking forward to seeing how everyone develops over the course.

It’s interesting to see how the idea has developed since we built an ontology for BBC Bitesize in 2011. Back then the focus was on modelling the content in a way that suited a product (Bitesize) rather than a way that reflected the UK education system. The reason for this was that back in 2011 the government (the natural publisher of an Ontology of UK education) was still some years away from laying down the building blocks, and the BBC had a temporary need to publish a Bitesize site using a triple store as they’d done for the 2010 World Cup.

At Outlandish we’re excited about the possibilities of the semantic web, while being sceptical of the state of current semantic technologies. We’ve built lots of prototypes using bleeding-edge technologies such as triple stores and found it interesting but impractical. AllegroGraph managed to create a triplestore that could query a trillion lines of data — it was, however, very, very slow. The BBC got around the problem by using many levels of caching, so that they only queried the data when it changed, but that undermines some of the benefits of dynamic publishing.

We’re watching the developments around bbc.co.uk/education very keenly — I’m sure there’ll be some ‘oohs’ and ‘aahs’ once they kick the technology into line.

Note that it’s a very simple implementation of the SVG path specification. It only understands straight line segments, not arcs and Bezier curves. For our purposes, this was enough, since the curves in country outlines are usually modelled as small facets rather than true curves.

You can get the code from GitHub.

Example usage:

$bounds = SvgBounds::fromPath('M 100 100L300 100 200 300z');
echo $bounds->getWidth(); //200
$bounds->extend(350, 100);
echo $bounds->getWidth(); //250

Transmedia is the new buzzword making the rounds at the moment and lots of production companies are feeling the pressure to involve different platforms when making new programmes. To most people it would seem it isn’t a new concept, and is just about using multimedia as part of the broadcast package, but I’m going to argue that it represents a cultural shift for most television production companies in how they think about the digital offering around linear output.

For the research project we needed to establish what we all meant by Transmedia. These were the key elements I felt were the most important for a successful Transmedia approach:

• Transmedia elements are planned right from the commissioning point – a part of the process rather than an add-on
• Enables deeper audience engagement in the content of the programme
• Encourages activity in the audience
• Rewards fans of the show with more content and more ways to get involved
• Lengthens the relationship the audience has with the programme
• The programme doesn’t have to be the centre, or the pinnacle of the brand
• Potential to reach a new audience on new platforms – different audiences might interact with you on the different platforms

That first point is, for me, easily the most important. If the non linear elements of the programme offering are added on after the initial programme concept has been signed off, they are just multi-media elements. Where transmedia truly becomes ‘Transmedia’, is when the package is thought of as a whole, right from the start. The non linear elements have a clear reason for being there (beyond offering video extras for super fans online) and add value to the overall brand and product.

There have been lots of programmes (BBC and non BBC) that have claimed to be Transmedia, but how many of them actually are?

The Code

http://marthasadie.wordpress.com/2012/03/21/notes-from-sxswi-adrian-hon-creating-the-code-a-bbc-transmedia-documentary-thecode/

Created by Six to Start for the BBC

A set of programmes that contained a secret treasure hunt and challenge to ‘crack the code’ built in to the filming. This is a good example of the transmedia elements being intrinsic to the programme development right from the start. It was relatively successful with a small demographic engaging deeply with the clues and others enjoying the mini-games that were also created a longside the programme.

An important point – you will never engage the entire linear programme audience with the transmedia elements you create, but you will engage a small sub set (or potentially new audience) more deeply and offer them more value through the activit

The Voice

http://www.bbc.co.uk/thevoice

An international hit, sold in many countries and the off-linear elements are certainly strong. All the judges (in the UK at least) have well established Twitter feeds and as part of their contracts were required to tweet. Hashtags are used consistently, and twitter conversations absolutely encouraged.

What actually made The Voice stand out over and above other programmes that do similar things (X Factor, Big Brother etc) was the fantastic use of Twitter Will.I.Am employed. He tweeted during the live shows, commenting on what was happening in a very open, honest and believable way (rather than being told to do it by his agent). People loved getting an extra insight in to what was actually happened, while it was happening. A true Transmedia element – adding to the value the entire brand offers audiences.

The Million Pound Drop

https://www.themillionpounddrop.com/

Channel 4 has spent a lot of money on building an interactive game that can be played at anytime, or preferably alongside the quiz show as it is being broadcast. It has been very successful in getting people to play along side the contestants (100,000 online players for some broadcasts). As the show is completely live, they can reveal how online players are doing

“Hairdressers in Wales did the best on that question”

This not only makes the people who are playing feel a part of the programme, it also encourages others to join in.

…And many others from the other side of the pond that I won’t go in to…

In short, Transmedia elements of a brand should feel natural, a key part of the content being created, as easy to access as the programme and adds to the overall brand experience for audiences. Can production companies get used to the idea of thinking about digital, face to face and mobile content with the same importance as the linear programming? If they don’t, they could be left behind.

As Julie Aldridge, Executive Director of the AMA, describes it:

The knowledge bank will be a central place for all cultural professionals to go to quickly get insight, advice and tried and tested practice on everything relating to how to reach and engage the public.

It will save marketers time, help cultural professionals develop their knowledge and skills, stop us collectively reinventing the wheel by sharing what works – and what doesn’t – and ultimately help arts organisations to improve their ability to bring art and audiences together.

This is an exciting opportunity for us to use our expertise in search, data handling and user interface design. We understand how important it is for arts marketers to find the quickly find the resources they need, and we are excited to have the opportunity to build a system to make this happen.

You can read more about the project in the AMA’s press release.

function xmlToArray($xml, $options = array()) {
	$defaults = array(
		'namespaceSeparator' => ':',//you may want this to be something other than a colon
		'attributePrefix' => '@',   //to distinguish between attributes and nodes with the same name
		'alwaysArray' => array(),   //array of xml tag names which should always become arrays
		'autoArray' => true,        //only create arrays for tags which appear more than once
		'textContent' => '$',       //key used for the text content of elements
		'autoText' => true,         //skip textContent key if node has no attributes or child nodes
		'keySearch' => false,       //optional search and replace on tag and attribute names
		'keyReplace' => false       //replace values for above search values (as passed to str_replace())
	);
	$options = array_merge($defaults, $options);
	$namespaces = $xml->getDocNamespaces();
	$namespaces[''] = null; //add base (empty) namespace

	//get attributes from all namespaces
	$attributesArray = array();
	foreach ($namespaces as $prefix => $namespace) {
		foreach ($xml->attributes($namespace) as $attributeName => $attribute) {
			//replace characters in attribute name
			if ($options['keySearch']) $attributeName =
					str_replace($options['keySearch'], $options['keyReplace'], $attributeName);
			$attributeKey = $options['attributePrefix']
					. ($prefix ? $prefix . $options['namespaceSeparator'] : '')
					. $attributeName;
			$attributesArray[$attributeKey] = (string)$attribute;
		}
	}

	//get child nodes from all namespaces
	$tagsArray = array();
	foreach ($namespaces as $prefix => $namespace) {
		foreach ($xml->children($namespace) as $childXml) {
			//recurse into child nodes
			$childArray = xmlToArray($childXml, $options);
			list($childTagName, $childProperties) = each($childArray);

			//replace characters in tag name
			if ($options['keySearch']) $childTagName =
					str_replace($options['keySearch'], $options['keyReplace'], $childTagName);
			//add namespace prefix, if any
			if ($prefix) $childTagName = $prefix . $options['namespaceSeparator'] . $childTagName;

			if (!isset($tagsArray[$childTagName])) {
				//only entry with this key
				//test if tags of this type should always be arrays, no matter the element count
				$tagsArray[$childTagName] =
						in_array($childTagName, $options['alwaysArray']) || !$options['autoArray']
						? array($childProperties) : $childProperties;
			} elseif (
				is_array($tagsArray[$childTagName]) && array_keys($tagsArray[$childTagName])
				=== range(0, count($tagsArray[$childTagName]) - 1)
			) {
				//key already exists and is integer indexed array
				$tagsArray[$childTagName][] = $childProperties;
			} else {
				//key exists so convert to integer indexed array with previous value in position 0
				$tagsArray[$childTagName] = array($tagsArray[$childTagName], $childProperties);
			}
		}
	}

	//get text content of node
	$textContentArray = array();
	$plainText = trim((string)$xml);
	if ($plainText !== '') $textContentArray[$options['textContent']] = $plainText;

	//stick it all together
	$propertiesArray = !$options['autoText'] || $attributesArray || $tagsArray || ($plainText === '')
			? array_merge($attributesArray, $tagsArray, $textContentArray) : $plainText;

	//return node as array
	return array(
		$xml->getName() => $propertiesArray
	);
}

The function takes a SimpleXMLElement object and returns as associative array. Crucially, it handles namespaces which none of the examples I could find online did.

Example

A complete usage example looks like this:

$xmlNode = simplexml_load_file('example.xml');
$arrayData = xmlToArray($xmlNode);
echo json_encode($arrayData);

Given an input XML file such as this:

<?xml version='1.0' ?>
<company>
	<name>Outlandish Ideas</name>
	<link href="http://outlandishideas.co.uk">Website</link>
	<person>Abi</person>
	<person>Harry</person>
	<person>Rasmus</person>
	<person>Tamlyn</person>
	<address street="yes">
		<street>Longford Street</street>
		<city>London</city>
	</address>
</company>

It produces output such as this:

{
    "company": {
        "name": "Outlandish Ideas",
        "link": {
            "@href": "http:\/\/outlandishideas.co.uk",
            "$": "Website"
        },
        "person": ["Abi", "Harry", "Rasmus", "Tamlyn"],
        "address": {
            "@street": "yes",
            "street": "Longford Street",
            "city": "London"
        }
    }
}

Notes:

• Attributes are given a prefix to distinguish them from child nodes e.g. “@street” and “street”
• If a node has text content as well as child nodes or attributes, that text content is stored in a key e.g. “$”
• If a node has multiple children with the same tag name, they are converted into a numerically indexed array e.g. “person”

The function also accepts an array of options as the second parameter. Two of these options bare a little explanation.

autoArray and autoText

In short: leave these as true for more readable output; set to false for more consistently parseable output.

XML makes life really hard for programmers because it allows attributes, text content and multiple child nodes with the same name all at the same time. That means that when it comes to representing an XML document as normal data structures (trees, hash tables, arrays, objects etc.) we’re forced to make some decisions.

In the above example, the text of the <title> element is assigned directly to the title key but the text of the <link> element is assigned to the $ key because of the href attribute. Now assume another XML file for Another Company contains this line: <title parentCompany=”Big Corp”>Another Company</title>. In that case, instead of {“title”: “Outlandish Ideas} you would get {“title”: {“@parentCompany”: “Big Corp”, “$”: “Another Company”}}. If this is a problem for you, set autoText to false and text content will always be assigned to a $ key, regardless of other attributes (see example below).

In the above example, again, we turn the <person> elements into an array because there are several of them. But what about a company with only one person? How would the function know what to do? One option is to use the alwaysArray option to provide a list of tag names which should always be considered arrays. Another is to turn autoArray off which converts all tags into arrays, regardless of other child nodes.

Here’s that XML file again, but this time with autoArray and autoText turned off:

{
    "company": {
        "name": [{
            "$": "Outlandish Ideas"
        }],
        "link": [{
            "@href": "http:\/\/outlandishideas.co.uk",
            "$": "Website"
        }],
        "person": [{
            "$": "Abi"
        }, {
            "$": "Harry"
        }, {
            "$": "Rasmus"
        }, {
            "$": "Tamlyn"
        }],
        "address": [{
            "@street": "yes",
            "street": [{
                "$": "Longford Street"
            }],
            "city": [{
                "$": "London"
            }]
        }]
    }
}

As you can see it’s much more verbose and harder to read. However the data structure is less dependent on the exact content of the document.

Finally, here’s a real world example of taking the RSS feed from this site and inserting it into a MongoDB collection:

$xmlNode = simplexml_load_file('http://outlandishideas.co.uk/feed/');
$arrayData = xmlToArray($xmlNode, array(
	'alwaysArray' => array('item', 'category'),
	'keySearch' => '.', //MongoDB doesn't allow dots in keys
	'keyReplace' => '_' //so replace with underscores
));
$m = new Mongo();
$m->test->feeds->insert($arrayData);

That’s all

This code is free for anyone to use. We hope you like it. Let us know if you found it useful.

Known issues

• The order of elements is not preserved.
• Namespaces are not preserved.
• The namespace prefix of the root element (if any) is not preserved.
• autoArray=false doesn’t create an array for the root element.

Download it from the WordPress site or simply search for “Disable deprecated” from Plugins > Add New in your blog’s admin interface.

Why?

When developing a WordPress website, theme or plugin, it’s important to set WP_DEBUG to true in wp-config.php. This tells WordPress to be more chatty about things that might be going wrong. Under the hood it turns on PHP error reporting and also enables WordPress’ deprecated messages. These messages are an important way to tell theme and plugin developers that certain functions, arguments or files have been deprecated and that their use is discouraged. Unfortunately, when a piece of code is marked as deprecated, it takes some time for all the plugin authors to update their plugins and until they do so, the offending plugins will be raising errors and warnings all over the place.

This plugin places a big band-aid over the whole thing by simply disabling those deprecated notices… thereby resolving the issue… forever.

Constructed over the course of about a month (with virtually no injuries!), the head and antlers are made of papier mache over a chicken wire structure, which are mounted on a block of varnished MDF. It was then just a case of ordering some suitably outlandish eyewear from amazon and blu-tacing them on. It is now mounted above our office doors, and looks right at home.

It doesn’t currently have an official name, but candidates so far include:

• Isaac (‘eyes’-ac, geddit?)
• John Deere
• Deirdre
• Terry (no pun here, we just like it)

If you can improve on these, or just want to put your weight behind one, drop us a line via the twitternet @outlandishideas. We’re also still not sure it’s living up to its moniker, and perhaps it should be a little more outlandish; maybe something involving LEDs, or some more eyes? All suggestions welcome.

The best setting for a hackday we’ve heard of

Our aim was to have some time away from our projects to be creative, and sample some local ale and have a few wanders on a beach. It seems we successfully achieved all three.

Our Hack is born

After an introduction to all things Field Studies we sat down to deliberate what we were going to build. We’d just about decided on making an ID Keypedia (ID Key in the Geography sense) when Dave and Jim – two Field Studies Council approached us with big puppy dog eyes and asked us to build something they really needed – a database and front-end to hold and visualize all the data that is collected by the school groups. Outlandish took on the challenge.

11am: The first day was mainly about figuring out exactly what data is collected by the different centres, in what format and trying to get our hands on as much of it as possible. This was far from the easy part. There was much head scratching and laptop searching to find as many spreadsheets as possible. We ended up with around 50 separate investigations on measuring river data spanning the last 3 years. Enough for us to start with.

Summary of functionality we aimed for:

• Ability to submit spreadsheets in to the system in a specific format
• Database to hold data
• Visualisations of data (average depth vs width through river, and over time)
• Animation of the data where possible and time permitting

Then it was coding time.

We hacked from about 3 until 10pm on the first day, giving us just enough time for a pint or two down at the local The Tower

Day two had a 3pm deadline when we would need to present what we had built. In the middle of the morning the lovely @rowstar who was doing a fantastic job of blogging, tweeting and soundclouding much of the weekend interviewed us on where we were and what we were trying to achieve:

By 3 pm we managed to get a pretty much working tool that did all the things we wanted to and it even got a vocal oooooh when we showed the rather lovely visualization of the cross section of a river bed (Thanks Tam).

The importer was built with the myriad spreadsheet formats in mind, so that it could deal with multiple worksheets per file, and multiple investigations per worksheet, and could intelligently guess what data the rows contained. Once the format was confirmed, it would remember it for the next time. The front end allowed the user to manage and explore each school’s investigation and each river site, visualizing cross-section dimensions, flowrates and discharge (tee hee). With a little more time we would have liked to incorporate some of the other data, such as the river gradient, and pebble size and shape.

For those of the technical persuasion, the tool was build using the PHP Zend framework on a mysql backend. We made use of the PHP excel reader for parsing and importing the Excel spreadsheets, jQuery and jQuery UI for general all-round front-end goodness, the datatables jQuery plugin for presenting the data in a nice sortable and searchable format, and Google chart tools for, well, the charts.

There was plenty more to see from the other teams – our favourite was the bat detector, created by Michael Saunby  from the Met Office. Not only a brilliantly fun tool, but something students could make in the class and try out themselves. Perfect for learning about more than just bats. We are going to have a crack at making one and seeing if there are any bats in Finsbury Park. We’ll keep you posted. Read about all the projects in this blog post on the Field Studies Council website: http://fschackday.wordpress.com/2012/05/22/fsc-hack-winners/

So the winners are….

Best Build – Outlandish’s River Cruncher

Best in Field - FLAIR (Field Log Analysis Instant Resource)

People’s Award – The Bat Men’s Heterodyne Bat Detector

Best Potential – Andy Piper & Neil Ford’s (with help from Bristol Hackspace) Floggr

Yes, you read that right. We won an award! We were really surprised and excited to have won in our first ever hackday as Outlandish. We were presented with a highly coveted Raspberry Pi

The train journey home was spent coming up with different ideas for what we are going to do with it. I’m sure you are all on tenterhooks to see what we might decide on. Watch this blog for a series on ‘Rasperry Pi-deas’ (geddit??).

Thanks so much to the Field Studies Council and all the organisers, with special mention to:

Ant Miller for being the brains behind it all and the best hackday host we’ve witnessed, for always being there, helping whenever we needed it and having never-ending energy and enthusiasm throughout the weekend. Only coming second in the enthusiasm category to @folkprincess Harriet.

Harriet, was fabulous throughout the weekend and really spurred us on to create something not only that was fun for the weekend, but also something that the Field Studies Council will hopefully use in the future.

Here are some screengrabs of the tool we created. Need something similar? It will take us slightly more than 2 days to do it, but you just say the word.