Now, it works perfectly, and wpa_supplicant no longer renegotiates every five minutes with the router.

Just try the following:

Then make it look something like this.

Download an iso from: http://www.debian.org/

Convert the iso to an img (.dmg) file.

I’ve moved around a lot over the course of my life, when I was younger because of my parents, and older with work and circumstance – and each move has produced a swathe of friends that [...]]]> Perhaps it’s an age thing, but I’ve latterly been thinking about what social media means to relationships over time.

I’ve moved around a lot over the course of my life, when I was younger because of my parents, and older with work and circumstance – and each move has produced a swathe of friends that I rarely see.

Now social media can make the distance and lack of face-to-face meeting up up a little easier, but over time there is an erosion of connection – that rooting to a particular place that in my mind seems to be the thing that grounds people. Relationships are built over time and the countless deliberate and non-deliberate interactions (i.e. I meet someone I wasn’t expecting to down the pub etc.).

When you have to be utterly deliberate about meeting up, perhaps a couple of times a year, it’s inevitable that the connection will become different.

So to the tittle of the post. As the years pass and there is less time for the forming of deep relationships based on shared experience (like time at university, or when friends are having children) what I’m finding is that I have a long list of Facebook and Twitter contacts, but who’s actually around to do something on Saturday night?

I expect it’s in some ways this is a reflection of the the very human trait that leads us all to question the hand we’ve been dealt. If I’d lived in the same place all my life, I’d want to have moved around to collect an armful of interesting experiences. Am I just wishing that I’d not missed out on the feeling of belonging to a place? After all, if you hate a place, it doesn’t matter who’s around on Saturday night if you don’t like any of them.

Social media brings people together that never would have in the past, but I think it allows for the amplification of our struggles with actually relating with one-another. If your friends all live far away, you will still need someone near by to have a pint with.

One of my colleagues mentioned dnsmasq – and he implemented it on his host machine to resolve names for various VM’s.

I didn’t really want to install it on [...]]]> When working with various virtual machines and browsers, your hosts file can start to look a little over subscribed, and rather difficult to manage.

One of my colleagues mentioned dnsmasq – and he implemented it on his host machine to resolve names for various VM’s.

I didn’t really want to install it on the host, so went for having it on the VM, so that each one could resolve it’s own list of domains. In the instructions, I’m making the assumption that the VM has a DHCP provided IP from the host only network within VirtualBox, and it’s host name (the name I’m connecting to from the host machine is devbox). Here’s what I did.

1. Install dnsmasq on Debian with apt

sudo apt-get install dnsmasq

2. Open up /ect/dnsmasq.conf and add:

address=/devbox/192.168.56.101

3. Restart dnsmasq

sudo /etc/init.d/dnsmasq restart

4. Then in your host machine’s /etc/hosts file add:

devbox 192.168.56.101

5. If you’re using OS X, create the folder /etc/resolver

sudo mkdir /etc/resolver

6. Create a named entry for your box

Mine’s called devbox, I’d do:

echo "nameserver 192.168.56.101" > /etc/resolver/devbox

And that should now work nicely – somesubdomain.devbox for example will  resolve to that VM.

Imagine…

You want to use some computing device to achieve a task, so you go to google – after all – someone must have tried to solve this problem with software somewhere. You search away, deftly clicking through links, finally coming upon Acme software, the answer to [...]]]> Trust is a massive issue with software today.

Imagine…

You want to use some computing device to achieve a task, so you go to google – after all – someone must have tried to solve this problem with software somewhere. You search away, deftly clicking through links, finally coming upon Acme software, the answer to all your searching. There before you is an application that will solve you problem perfectly.

Presuming there’s nothing stopping you (e.g. cost, incomprehensible download instructions, platform availability), you go on and install, making the assumption that the developer has utterly benign intentions and there isn’t anything untoward going on.

In that single act of installation, you take your chance; is it legitimate, or is your machine now part of a bot net?

Which is why things like code signing and app stores amongst other things exist. Whilst not perfect they attempt to mitigate some of the risks.

There is no perfect system and there never will be; all we can do is aim for the situation that is just less riskier. Just think about these two constructs for a moment.

Firstly code signing. When a developer signs code with a certificate from a Certificate Authority, the CA is confirming that the developer is who they say they are. When your OS asks you to confirm that Verisign for example knows who Acme software of 42 Wallaby Way, Sydney are, you are trusting that Verisign has checked them out, given them a phone call for example, checked articles of incorporation etc – i.e. carried out a little bit of background checking. But who are Verisign, do they have a relationship with you (of course not)? Are all CA’s thorough? And because there are so many of them, who says who you can trust them anyway?

If you write code, you probably think you know the answer to these questions, but to the general user, they’ll just click “OK”, and think nothing of it – and that says nothing of self-signed code (where the developer generates their own certificate, and signs the code with it).

And then the app store? Some of these (in the case of Apple) provide the certificates, and the gateway to users. Users go to them, hopefully able to trust that they have carried out the due diligence of a CA, perhaps actually checking the code (which is not a requirement of a CA – so they are taking the duty one step further). Of course this requires that the user has a level of trust in the app stores proprietors, and believes they aren’t going to do anything evil (same would apply to the CA, but general users will already have that with Google or Apple – unlikely with Verisign). Of course, the OS manufacturer is actually the one asking you to trust the certificate from the CA, but the question is always posed the other way around – as a request to the user to trust the CA by clicking ok.

So what is wrong with the app store model?

The first one is that everyone reaches for is that the app store proprietor is given too much control – ultimate censorship – but it has proven to be a bit of a moot point in most circumstances. When the Apple app store started, there where many cases of software being prevented from approval, and then the accompanying furore. But these are now a much rarer occurance (or perhaps no one cares). If we take the case of Opera, in my opinion, it has such a terrible implementation on iOS that I wonder if there’s more of a back story than they would care to admit to.

If there’s anything wrong with this model, it’s that it isn’t prefect; so when it goes wrong we think – hey, what the? I thought they made these things bullet proof. As most users will always click ok – right here and now, the app store model seems like the best solution.

Which leads us to the disappointment with our human endeavours – there has never been (or will be) a perfect situation – just ones that are less bad. Failure leads to improvement, but as we are utterly unable to foresee all circumstances, there will always be unknown unknowns.

MPD will play external audio streams, but the problem with the BBC streams are that they exist behind tokenised URL’s. So here’s a quick PHP script that you [...]]]> Just a quick something I finally got around to this morning – getting BBC radio streams (which are often a little opaque) to play on MPD.

MPD will play external audio streams, but the problem with the BBC streams are that they exist behind tokenised URL’s. So here’s a quick PHP script that you can set up on a cron (say, run every hour), which will create m3u files with the two tokenised streaming URL’s contained as entries for MPD to play.

#!/usr/bin/php5
<?php
$path        						 	 = 	'/path/to/your/mpd/playlists/';

$stations							 	 =	array(
												  'Radio4'	=>	'http://www.bbc.co.uk/radio/listen/live/r4_aaclca.pls',
												  'Radio3'	=>	'http://www.bbc.co.uk/radio/listen/live/r3_aaclca.pls'
												  );

foreach ($stations as $key => $value) {

	$pls           	 					 = 	file_get_contents($value);
	$fileName        					 = 	'{$key}.m3u';

	preg_match_all('/File[12]=((.?)+)/i',$pls,$matches);

	file_put_contents($path . $fileName, join('\n',$matches[1]));	

}

The above examples grabs the .pls files for radio 4 and 3 from the BBC servers, and pushes them into the m3u files.

Hope that helps someone.

My biggest [...]]]> The problem of updating and versioning database tables in Apcelerators’ Titanium API is made a little trixy by the nature of the number of inherent floors with what’s available, and a lack of comprehensive documentation. I’d already dealt with versioning within my model classes previously, but had glossed over the seed data.

My biggest problem was that one of the tables had to have just over 9000 rows (and perhaps more once the application is distributed) inserted. The only options available according to the documentation were to read the file in, explode on a new line char into an array, then munch through the array keys inserting the data as you go.

Possibly fine if the data is small, but will bomb the device as we’re talking about 2.2MB of text.

The solution it seemed was to use the new buffers object available I think since version 1.7 of the SDK. The solution is a bit kludgy and rather slow (so needs a some improvement), but it actually works, and most importantly the device survives the process.

So here’s the code:

var seedDataFile			 =	Ti.Filesystem.getFile(Ti.Filesystem.resourcesDirectory + "data/", model.table + ".sql");

if (seedDataFile.exists()) {
					
	var fileStream			 = 	seedDataFile.open(Ti.Filesystem.MODE_READ);
	var buffer 				 = 	Ti.createBuffer({ length: 1024 });
	var bytesRead			 = 	0;
	
	while ((length = fileStream.read(buffer, bytesRead, 1)) > 0) {
		
		bytesRead 			+= 	length;
		
		var str 			 = 	Ti.Codec.decodeString({
			
			source			 : 	buffer,
			charset			 : 	Ti.Codec.CHARSET_UTF8,
			length			 : 	bytesRead,
			position		 : 	0
		
		});
		 
		var eol 			 = 	str.charAt(str.length - 1);
		 
		if (eol == ";") {
		 	
		 	Model._db.execute(str);
		 	
		 	bytesRead 		 = 	0;
		 	buffer.clear();
		 	
		}
		
		str					 =	null;
		
	}
					
	fileStream.close();
	buffer.clear();
	buffer.release();
	
}

Basically it does the following:

1. Open the file into a fileStream object
2. Read one byte at a time into the buffer (in this case the buffer is 1Kb – so hopefully I won’t have an insert query longer than that).
3. Check to see if we’ve read in a semi-colon (could expand this to an nl char using regex, but I wanted to save on processing time).
4. If there’s a match, take the contents of the buffer, and use that as the query
5. Reset everything, and clear the buffer.
6. Continue on, and on etc…

Now, this worked fine in iOS, taking about 7 minutes to do the 9000 odd rows. Android, well that sorry state of affairs took nearly two hours. I’m thinking that there’s room for improvement there, but it will work for most cases. Hopefully this will help someone out.

When using the internationalised strings.xml, it is possible to do [...]]]> I came across a rather annoying annoyance in the Appcelerator Locale API today, but only to do with the Android platform. It took a while to figure out what was going on, and had to read through the Google documentation to find an answer.

When using the internationalised strings.xml, it is possible to do replacements using String.format. For example:

<?xml version="1.0" encoding="UTF-8"?>
<resources>
	<string name="format_string">%s, exceeds the length of %s</string>
</resources>

Then:

var formattedText = String.format(L("format_string"),12,7);  // 12 exceeds the length of 7

The replacements are made according to the printf specification, and all is sweetness and light. That is until you try it in Android.

First of all, it refuses to compile with a rather annoying message. It turns out that there is a different formatting required, which is fine, but you can’t specify platform dependent i18n xml files, and the Android formatting doesn’t work with iOS.

So the above needs to become:

<?xml version="1.0" encoding="UTF-8"?>
<resources>
	<string name="format_string">%1$s, exceeds the length of %2$s</string>
</resources>

The only solution would be to do a find and replace before you compile for a particular platform. Why isn’t this in the documentation – you would need to ask the people at Appcelerator…

Now to achieve the same thing, [...]]]> With all the changes to Firefox of late, we found that some of the new JavaScript objects have had a little overhaul too.

Until recently, we were doing the following:

var file = form.Image.files[0];

if ( file.fileSize > 15000000) {
    alert("You're file is too large");
}

Now to achieve the same thing, the fileSize is changed to size:

var file = form.Image.files[0];

if (file.size > 15000000) {
    alert("You're file is too large");
}

This is also true of fileName to name. See here some more info from MDN.

So looking through log files, I found that MySQL [...]]]> I’ve just upgraded my Debian MythTV server install (just a backend), and for some reason it completely broke. Googling around, I found some references to missing dependencies, but it installed just fine; so what the hell was going on – I just wanted to watch TV…

So looking through log files, I found that MySQL was denying access for some reason, even though the MythTV user existed, and had permissions to access the mythconverg database.

I had to completely delete the MythTV user, flush privileges, add it again (making sure that it can connect from any host on my LAN), and then re-grant permissions – how very odd. Hope that helps someone.